java中Collection集合关键点记录

zhangkai__

已于 2022-06-11 13:40:36 修改

阅读量127

点赞数 7

文章标签： java 开发语言

于 2022-06-11 11:40:04 首次发布

本文链接：https://blog.csdn.net/zhangkai__/article/details/125232879

版权

java中集合总结与理解

写在前面

*数组，集合都是对多个数据进行存储操作，简称为容器。

注：这里的存储指的是内存层面的存储，不是磁盘上的持久化存储。

一.集合分类及应用场合

主要是要将一类相同属性的信息整合起来，需要用到集合。集合中可以放多种类型的数据，不受限制。在这里插入图片描述

二.Collection类

1.集合一个特点：

只能存放引用数据类型的数据，如果传入基本数据类型，会进行自动装箱处理。

2.遍历方式

//集合遍历
//1.增强for循环
for(Object o:col){
    System.out.print(o+",");
}
//2.迭代器集合对象拥有iterator方法
Iterator it=col.iterator();
while (it.hasNext()){
    System.out.print(it.next()+",");
}

3.List接口

//List重写方法add()
list.add(1,"avv");
//set修改方法0下标和修改后值
list.set(0,22);
//list.remove(n)n为Intager类型，则删除的是下标n的值
//当n为Obj类型的时，删除的是元素值为n的数据。
list.remove(2);
//get(n)通过索引，输出下标为n的元素值
list.get(1);
//list因为有get方法，所以可以普通for循环遍历

3.1ArrayList实现类

jdk1.7–底层源码是数组，调用构造器时，初始化== 数组长度10 ==，扩容的时候为原数组的1.5倍。（有些类似于StringBuilder）
jdk1.8–底层源码是数组，调用构造器时，初始化== 数组长度为空 ==，调用add方法后，才给新数组赋长度为10，这样节省了空间。
ArrayList线程安全，但效率高

3.2Vector实现类（主要对比与ArrayList的区别）

底层仍然是Object数组，int类型属性表示数组中有效长度
底层数组调用构造器时，初始化== 数组长度10 ==
当调用add方法时，底层数组扩容为原数组的2倍
相对于ArrayList来说，Vector是线程安全的，但效率低下。

3.3 ArrayList和Vector共同特点

由于底层实现是数组实现的，所以查询效率高并且可重复
缺点在于增，删效率低下

3.4泛型

3.4.1作用：

将集合内的数据类型统一化，不是泛型指定类型则不能加入集合，这样会使集合后续遍历简单化.

注：泛型对应数据类型都是引用数据类型

3.4.2实例:

ArrayList<Integer> al=new ArrayList<Integer>();//JDK1.5
ArrayList<INteger> al=new ArrayList<>();  //JDK1.7

3.4.3应用场合

泛型其本质还是多态，在抽象接口或者类的情况下使用泛型先预留好位置，当具体实现类定义集合时，再去真正定义集合的具体类型。

//没有指定泛型的引用数据类型，E可代表任意类型
public class Test003<E> {
    int ads;
    E sex;
    public void a(E n){
    }
    public void b(E[] m){
    }
}
//这时子类E为Integer型，创建对象默认Integer型
class Testson extends Test003<Integer>{

}
//父类不指定泛型类型，子类就也是泛型类，创建对象时才确定E的类型
class Testson01<E> extends Test003<E>{

}

class sds{
    public static void main(String[] args) {
        //首先需要对泛型类实例化对象
        //1.实例化泛型类但不指定泛型，默认为Object类型
        Test003 ts=new Test003();
        ts.a("abc");
        ts.b(new String[]{"s","d","g"});
        //2.实例化明确指定泛型类,E的类型为传入的泛型类（推荐）
        Test003<Integer> ts2=new Test003<>();
        ts2.a(4);

        //继承父类，子类自动是父类的泛型类
        Testson tso=new Testson();
        //自动Integer类
        tso.a(5);
    }
}

3.4.4泛型类的一些特点

泛型类可以定义多个参数类型
泛型类的构造器不能加入泛型
不同泛型的引用类型不可以相互赋值
泛型不指定，被擦除，相当于还是原来的Object类型
泛型类中静态方法不能使用累的泛型（与构造方法原理类似）
不能直接使用E[]进行创建，因为并不知道它是什么类型的

3.4.5泛型方法

要求这个方法的泛型的参数类型和当前类的泛型无关

//不是泛型方法
public void a(E e){
}
//错误方法
public static void a(E e){
}
//泛型方法
public<T> void b(T t){
}
//泛型静态方法
public static<T> void b(T t){
}

T的类型是在调用该泛型方法的时候确定的，而不是创建类对象时
泛型方法可以是静态方法

问题，为什么泛型方法可以是静态方法，而泛型类方法不能是不能是静态方法？

答：因为普通类需要的E是要在对象创建的时候指定的，而静态方法是随着类就已经产生了，这就出现了先有类，但是没有对象，不知道E的类型；但是静态泛型方法虽然也是和类一起创建的，但是由于该方法不和类对象绑定，所以即使先有类也不需要提前知道T的类型，调用方法再指定就可以了。

注：A和B是父子类的关系，但是G和G不存在继承关系，是并列的关系。

3.4.6通配符

List<Object> list1=new ArrayList<>();
List<String> list2=new ArrayList<>();
//A和B是父子类的关系，但是G<A>和G<B>不存在继承关系，是并列的关系。
//加入通配符“？”后，G<?>就变成了G<A>和G<B>的父类
List<?> list=null;
list=list1;
list=list2;

通配符作用：当一个方法使用通配符后，可以传入多种类型数据

注：方法的遍历用增强for循环时，前面应该是Object类型。

3.4.7 泛型受限

在这里插入图片描述

3.5LinkedList实现类

3.5.1 常用方法

offer()//添加元素在尾端
offerFirst/offerLast() //添加元素在首尾
poll() //删除链表头元素并且输出
pollFirst/pollLast() //删除链表头尾元素并且输出
remove()不能用在空链表的删除，而poll可以。

3.5.2遍历方式

除了前面三种方法，还有一种变形：

//这种方式比传统迭代器遍历更好的地方在于 对象随着for循环的结束而消亡，比传统迭代器更节省空间。
for(Iterator<String> it =List.Iterator();
it.hasnext();){
	System.out.println(it.next());
}

3.5.3底层实现

底层实现是用双向链表实现的。

在这里插入图片描述

3.5.4 面试题

1.Iterable,iterator(),Iterator之间的区别和联系
在这里插入图片描述
答：iterator()方法是Iterable接口中的一个抽象方法；

而iterator()抽象方法在实现类中实现时，返回一个Iterator接口类型。

4.set接口

4.1特点

相对于list接口，set接口中元素值唯一，并且无序，无序并不是随机。

4.2 遍历方式

由于set接口无序，所以不能有索引方法，因而不能使用普通for循环

迭代器
增强for循环

4.3 hashset实现类

若使用add方法添加两个基本数据类型的相同元素，只会成功放入第一个

底层原理
当填入自定义类型时，不满足唯一，无序，这是由于没有重写hashcode和equals方法

HashSet <Person> ps=new HashSet<>();
ps.add(new Person(16,"xiaoming"));
ps.add(new Person(16,"xiaohong"));
ps.add(new Person(16,"xiaoming"));
ps.add(new Person(17,"xiaohei"));
System.out.println(ps);

结果（没写前）：[Person{age=16, name=‘xiaohong’}, Person{age=17, name=‘xiaohei’}, Person{age=16, name=‘xiaoming’}, Person{age=16, name=‘xiaoming’}]

结果（重写后）：[Person{age=16, name=‘xiaoming’}, Person{age=16, name=‘xiaohong’}, Person{age=17, name=‘xiaohei’}]

4.4linkedhashset 实现类

实现唯一且有序，原理是：在所有元素上用链表串起来，每个元素位置固定。

4.5比较器

4.5.1内部比较器

1.String类实现了一个抽象方法compareTo()方法，该方法返回int类型值，实际原理：先比较两者长度，再用ASCII码值相减。

2.自定义类相比较时，需要该自定义类继承comparable接口，其中泛型为该类的类型，然后重写compareTo()方法，其中需要对比那个属性，参数就放入那个属性。

public class Student implements Comparable<Student> {
public int compareTo(Student o) {//重写编写排序规则
        if (this.age > o.getAge()) {
            return 1;

4.5.2外部比较器

自定义类外比较类继承comparator接口，重写compare()方法，该方法有连个参数，对应两个对象；

外部比较器相对更优秀，多态，扩展性好；

public class Student implements Comparator<Student> {
public int compare(Student o1, Student o2) {
        return o1.getAge() > o2.getAge() ? 1 : (o1.getAge() == o2.getAge() ? 0 : -1);
    }

4.6 TreeSet 接口

4.6.1特点

元素唯一且有序（升序）

4.6.2底层

基本类型—>内部比较器

自定义类型—>外部比较器

4.6.3 遍历方式

中序遍历

4.6.4 TreeSet

TreeSet 放入元素

当利用外部比较器时，必须自己制定:

Comparator<Student> com =new BiJiao();
TreeSet<Student> ts=new TreeSet<>(com);