Java集合

 

 

Java的集合其实就是数据结构在Java中的实现,其实之前写了几篇文章介绍数据结构,只写了栈和队列。现在准备介绍一下

1.数组Array

2.栈Stack

3.队列Queue

4.链表Linked List

5.哈希表Hash

6.堆Heap

7.图Graph

8.树Tree

 

 

不想再去写数据结构的实现原理了,只写一下集合的使用得了。

 

Java里面有数组,那为什么还要使用集合呢?原因是数组有以下缺点:

数组的缺点:

1.数组长度不可变,一旦数组初始化,长度就固定了。

2.数组只能存储同类型的数据,除了Object数组,但是Object一般都带来了装箱和拆箱的问题。 

 

在处理一个数据结构的实现,例如栈,堆,链表什么的,你得使用数组去自己实现。这样每次换个项目你就得去重写,很麻烦。这就出现了集合的概念,集合就是 数据结构的具体实现,直接使用就行了。

Java的集合都在Java的工具包里面,这个包叫 Java.util  

 

 

开始介绍集合了

 

一、Vector数组   (这个Vector不使用,推荐使用ArrayList,下面介绍ArrayList时有介绍原因。这里还是了解一下)

 Vector这个类,直接ctrl+鼠标左键,我们看一下他的源码,大致是这样的:

我们可以看到,他其实就是一个Object的一个数组而已,初始化数组默认是10,你也可以传入参数自己去定义初始的大小。

我们写一个Vector数组的代码:

package com.day16;

import java.util.*;

public class VectorDemo {
    public static void main(String[] args) {
        Vector vector=new Vector(5);
        vector.add("许嵩");
        vector.add(new Date());
        vector.add(123);

        System.out.println(vector.size());
    }
}

输出结果就是3.可以看到,我们添加了字符串,时间,数字这三种格式,因为Object是所有类型的基类。这里其实涉及到了装箱和拆箱的操作,这个是会损耗性能的。从Java5开始,Java就有了一个语法糖,就是我们上面写的,不用手动的去装箱了,其实语法糖的背后,Java帮我们装箱了而已。

 其实,存储的都是对象,例如:

package com.day16;

import java.util.*;

public class VectorDemo {
    public static void main(String[] args) {
        Vector vector=new Vector(5);
        vector.add("许嵩");
        vector.add(new Date());
        vector.add(123);

        StringBuilder sb=new StringBuilder("许嵩");
        vector.add(sb);
        System.out.println(vector);
        sb.append("最佳歌手");
        System.out.println(vector);
    }
}

 输出结果就是:

[许嵩, Sun Nov 04 18:21:35 CST 2018, 123, 许嵩]
[许嵩, Sun Nov 04 18:21:35 CST 2018, 123, 许嵩最佳歌手]

 Vector类存储的原理:

1.表明是Vector类的对象,实际底层还是Object数组

2.只能存储任意类型的对象

3.存储的对象都是对象的引用,而不是对象本身

 

 

 Vector类的一些方法:

        Vector vector=new Vector(5);
        Vector vae=new Vector(5);

        //增加
        vector.add("许嵩");
        vector.add(0,"许甜甜"); //增加元素,指定位置
        vector.addAll(vae); //这个添加一个集合, 实现Collection接口的任意集合都可以
        //这里说一下,add()和addAll()方法都可以去添加集合,但是添加的方式是不一样的,可见下图所示

        //修改
        vector.set(0,"Vae");//第一个指定元素位置,第二个参数为修改后的数据

        //删除
        vector.remove("许嵩");//移除指定的元素,如果有多个许嵩,只删除第一个找到的
        vector.remove(0); //移除指定位置的元素
        vector.removeAll(vae); //删除当前集合中的另一个集合的所有元素
        vector.retainAll(vae); //删除两个集合中相同的元素,其实就是求交集

        //查询
        vector.size(); //返回集合的元素个数
        vector.isEmpty(); //判断当前集合中元素是否为0
        vector.get(0); //查询指定位置的元素
        vector.toArray(); //把集合对象转化为Object数组,这个底层是copy了一份新的集合元素,集合本身元素不变

下面这两张图,第一张是add()和addAll()的区别。第二张是retainAll()的原理,其实就是交集。

 

数组类这里,推荐使用ArrayList类,ArrayList类的操作和Vector是差不多的

Vector和ArrayList的关系:

1):底层算法都是基于数组.

2):ArrayList是集合框架里提供的新的变长数组.Vector是ArrayList的前身.

3):Vector相对于ArrayList来说,线程更安全,但是性能较低.

 

二、Stack 栈

栈的特点是后进先出。这个我在数据结构的文章里面介绍的很详细 数据结构之栈

栈在生活中的体现例子有这些:

1.聊天软件发来的消息,后发的消息在最上面,想想你的QQ,微信,后面发的人的消息在最上面

2.子弹弹夹,先装的子弹都在最下面,最后一个装的在第一个,也是最先打出的子弹

直接写出几个方法吧

package com.StadyJava.day16;

import java.util.*;

public class StackDemo{

    public static void main(String[] args) {
        Deque stack=new ArrayDeque();
        stack.push("许嵩");
        stack.push("许甜甜");//push()是进栈
        System.out.println(stack);
        System.out.println(stack.isEmpty());//判断栈是否为空
        System.out.println(stack.peek());//取出栈顶的元素,但不删除
        System.out.println(stack.pop());//取出栈顶的元素,并且删了它
        System.out.println(stack);

    }
}

输出结果:

[许甜甜, 许嵩]
false
许甜甜
许甜甜
[许嵩]

之所以使用

 Deque stack=new ArrayDeque();

而不使用

Stack stack=new Stack();

的原因是,Java提倡第一种写法,而且栈顶的元素是在第一位的。下面讲队列的时候也会使用这个,就是一接口

 

三、ArrayList 数组

这个和Vector类的数组是一样的,方法都是差不多,内部也是Object数组。所以方法就不介绍了,一模一样。但是他们的区别很重要,看

这个是Vector的add方法:

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

这个是ArrayList的add方法:

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

最大最大的区别在于Vector的方法有synchronized关键字,这个是线程安全里面的同步方法!

所以这里我对比一下Vector和ArrayList的区别:

1.Vector所有的方法都使用了synchronized修饰符  多线程安全,但是性能比较低

2.ArrayList所有的方法都没有使用synchronized修饰符 性能快但是多线程不安全

3.及时在多线程的情况下,也不要使用Vector,因为Java推出了一个方法是 List Arraylist=Collections.synchronizedList(new ArrayList());  你只需要把你的ArrayList数组放到这个方法里面,就不用担心多线程下不安全的事情了,所以,不要使用可怜的Vector

4.如果查询某个元素木有查询到,java7之前,ArrayList会返回一个Null 但是Java7之后,ArrayList会返回一个空的数组,return Collections.emptyList(); 

5.在创建数组初始化的时候,Vector上来就分配了10个空间,而ArrayList在创建的时候创建了一个空数组,大小是0,只有你在存进去第一个数的时候ArrayList才会扩充大小为10,这样性能高,也不会浪费空间

 

四、LinkedList

LinkedList类:底层使用的单链表操作/双向链表/单向队列/双向队列.

LinkedList多线程不安全,需要Collections.synchronizedList()方法

LinkedList有get()方法,但是没有索引,只有数组才有索引,链表没有,Java2开始,有一个变量充当索引,所以也可以使用get()方法,但是要少用,LinkedList不擅长做查询操作,最擅长做添加和删除操作。

 

讲到这里,讲了好几个集合了,区别呢,共同点呢?是时候放出这张图了。我们上面讲的4个集合,都是实现了List接口的,都有元素可以重复,记录添加顺序的特点。 

 

 

ArrayList和Vector和LinkedList三个什么时候用:

Vector打死不用

添加和删除操作频繁使用LinkedList

查询频繁使用ArrayList

一般来说,还是查询频繁的情况多一些,所以ArrayList还是比较常用的。

 

 集合的迭代

已经讲了4个集合了,现在讲一下集合的迭代,迭代就是遍历集合内的所有的元素,取出来,有以下方法:

package com.StadyJava.day16;
import org.hibernate.validator.constraints.NotEmpty;
import java.util.*;

public class SetDemo {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("A");
        list.add("B");
        list.add("C");

        //迭代方法1,for循环
        for (int i = 0; i < list.size(); i++) {
            Object object=list.get(i);
            System.out.println(object);
        }

        //迭代方法2,foreach循环
        for (Object object:list) {
            System.out.println(object);
        }

        //迭代方法3,迭代器
        Iterator it=list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

 

这里要讲一下foreach循环

foreach循环在操作数组的时候,其底层就是for循环,有一个索引去获取数组的元素。

foreach循环在操作集合的时候,其底层其实是iterator迭代器,在foreach循环的时候,如果调用了集合的remove删除方法,会引发并发修改异常的报错

原因如图所示:

你如果调用集合的remove()方法去删除左边的元素,但是右边的迭代器线程的元素木有删除啊,所以就引发了并发修改异常的错误。那么意思就是说,使用foreach迭代集合的时候,不能删除了???

答案是可以删除,但是需要使用迭代器自己的remove()方法,如下:

package com.StadyJava.day16;

import java.util.*;

public class VectorDemo{

    public static void main(String[] args) {

        List list=new ArrayList();
        list.add("A");
        list.add("B");
        list.add("C");

        Iterator it=list.iterator();

        while(it.hasNext()){
            if ("B".equals(it.next())) {
                it.remove();
            }
        }
        System.out.println(list);

    }
}

 

讲完了集合的迭代,再讲一下什么是泛型。

泛型

 

 为什么要使用泛型?

1.Object类型需要装箱和拆箱,需要我们手动的去强转

2.有的时候需要集合中的元素类型都得一样,Object集合不能满足

3.如果需要多类型的集合,就得多写几种集合,违背单一原则

 

怎么写泛型?

package com.StadyJava.day16;

//泛型的使用就是在类后面加一个<T> 然后里面的元素使用T来修饰就完事了
class Point<T>{

    private T x;
    private T y;


    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }
}


public class SetDemo {
    public static void main(String[] args) {
        // Point point=new Point();
        //如果泛型类不指定类型的话,默认是Object类型,这样又会涉及装箱拆箱,还要我们自己去强转,所以还是指定类型吧
        Point<String> point=new Point<String>();
        point.setX("许嵩");
    }
}

 

通过反编译,我们可以发现,泛型其实也是一种语法糖,让我们开发人员写的简单一点,其实底层还是Object类型在强转。所以泛型也涉及到装箱拆箱,也会消耗性能,但是不用我们手动去强转了

 泛型方法,由于泛型类只适用于非静态方法,静态方法就得自己写

泛型类在被使用的时候,要明确类型的,例如子类继承泛型类,就要声明泛型类的类型。

 

泛型的通配符和上限、下限

package com.StadyJava.day16;


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

public class SetDemo {
    public static void main(String[] args) {

        List<Integer> list1=new ArrayList<>();
        List<String> list2=new ArrayList<>();
        dowork1(list1);
        dowork1(list2);

    }

    //这个就是通配符,只能作为参数
    private static void dowork1(List<?> list){}

    //这个就是通配符的下限,必须是Number或者Number的子类类型的
    private static void dowork2(List<? extends Number> list){}
    
    //这个就是通配符的上限,必须是Number或者Number的父类类型的
    private static void dowork3(List<? super Number> list){}

}

 

泛型的擦除和转换

泛型的擦除有两种:

1.代码编译之后泛型就消失了,擦除了。这个可以去反编译一下Java代码(泛型的自动擦除)

2.当带有泛型的集合赋给不带泛型的集合之后,泛型就会被擦除(泛型的手动擦除)

第一种没什么好讲的,来讲讲第二种,看代码:

package com.StadyJava.day16;

import java.util.*;

public class VectorDemo{

    public static void main(String[] args) {

        //泛型的擦除
        List<Integer> list1=new ArrayList<>();
        list1.add(123);
        //我定义了一个Integer类型的数组,现在赋给String类型的数组试试
        List<String> list2=null;
        //list2=list1;  报错,不同类型的肯定不能赋予
        //试试泛型的擦除
        List list3=null;
        list3=list1; //这个时候list3就已经没有类型了,就可以泛型擦除了
        list2=list3;//这个时候,我们把擦除泛型的list3赋给list2,居然成功了!我们绕过了Java的检查
        String num1=list2.get(0); //报错,本质和下面的一样
        String num2=123; //报错



    }
}

虽然我们使用了泛型的擦除让Integer类型的数组赋给了String类型的数组,但是这样是不安全的,所以不要这样做。

 

堆污染:当一个方法即使用泛型的时候也使用可变参数,此时容易导致堆污染问题。

这个了解一下就可以了,Arrays类里面有一个方法就是堆污染的,就是下面的这个方法,@SafeVarargs就是一个注解,作用是掩盖住堆污染的错误,就是 一种掩耳盗铃的作用。

 @SafeVarargs
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

 

 

List接口已经写完了,改Set接口了,上面神图里面说了,Set接口的特点就是元素不允许重复,元素插入没有顺序。

一、HashSet

来看一个元素没有顺序的例子

package com.StadyJava.day16;
import java.util.*;

public class SetDemo {
    public static void main(String[] args) {

        Set<String> set=new HashSet<>() ;
        set.add("X");
        set.add("1");
        set.add("V");
        set.add("e");
        set.add("V");  //Set不允许重复,所以这个V没保存
        System.out.println(set);

    }
}

输出的结果却是:

 

上图就是说,最好哈希表中的HashCode和Equals都相同,如果我们自己写了一个类,希望这个类的对象存储到HashSet里面,那么我们需要重写HashCode和Equals方法

package com.StadyJava.day16;
import java.util.*;

class Student{

    private String name;
    private Integer xuehao;
    private Integer age;

    public Student(String name, Integer xuehao, Integer age) {
        this.name = name;
        this.xuehao = xuehao;
        this.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 Objects.equals(name, student.name) &&
                Objects.equals(xuehao, student.xuehao);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, xuehao);
    }
}

public class SetDemo {
    public static void main(String[] args) {

        Set<Student> set=new HashSet<>() ;
        set.add(new Student("许嵩",1,32));
        set.add(new Student("许嵩",1,33));
        set.add(new Student("蜀云泉",3,23));

        System.out.println(set.size());
        System.out.println(set);
    }
}

我规定的name和xuehao一样的时候才算重复,所以上面代码的输出结果是2.

这里说一下,Idea里面创建构造器和HashSet、Equals的方法,单机鼠标右键,选择

 

选中自己需要的字段就可以了,代码不需要自己写

 

二、LinkedHashSet

 我们都知道了Set接口经典的实现类HashSet,Set接口都是不允许元素重复,不记录元素添加顺序的。但是,我现在想要一个元素不允许重复,但是可以记录元素添加顺序的集合。当然有了

LinkedHashSet类是HashSet类的一个子类,里面有哈希算法,也有链表。

LinkedHashSet特点:

1.元素不允许重复

2.元素添加有顺序

package com.StadyJava.day16;
import java.util.*;


public class SetDemo {
    public static void main(String[] args) {

        Set<String> set=new LinkedHashSet<>() ;
        set.add("V");
        set.add("a");
        set.add("e");

        System.out.println(set);
    }
}

由于比HashSet多了一个链表来记录顺序,所以效率是低点的,了解一下

 

 

三、TreeSet

TreeSet集合底层使用的是红黑树算法,会对元素进行一个默认的自然排序。这就要求,TreeSet集合中的元素必须类型相同,否则你怎么排序?

package com.StadyJava.day16;
import java.util.*;

public class SetDemo {
    public static void main(String[] args) {

        TreeSet set=new TreeSet() ;
        set.add("c");
        set.add("a");
        set.add("e");

        System.out.println(set);
    }
}

 

 果然是默认排序的

 

总结一下Set集合的这三个实现类

 

 

最后来讲一下Map,Map其实并不算是集合,他只是两个集合之间的一种映射关系。Map本身就是最高接口,并没有继承于Collection接口,只有继承Collection接口的才算是集合

Map就是两个集合之间的映射关系,由key-value组成,也称之为键值对Entry ,所以Map也可以理解为由一个个Entry组成的,是不是有点 Set<Entry>的意思,由于Map没有继承Collection接口和Iterable接口,所以Map是不能使用foreach迭代的,但是别急,还有其他方法可以实现Map的迭代,有3种方法,看一下Map的主要方法:

package com.StadyJava.day16;
import java.util.*;

public class SetDemo {
    public static void main(String[] args) {

        Map<String,Object> map=new HashMap<>();
        map.put("key1","许嵩");
        map.put("key2","林俊杰");
        map.put("key3","蜀云泉");
        map.put("key4",1);  //我的第二个集合是Object类型的,所以我可以存汉字和数字

        System.out.println(map);  //Map的key是不允许重复的,value可以重复
        System.out.println(map.containsKey("key1")); //看看当前Map中有没有这个key
        System.out.println(map.containsValue("许嵩")); //看看当前Map中有没有这个value
        System.out.println(map.get("key3"));  //根据key获取value
        System.out.println(map.size());  //键值对的个数
        System.out.println(map.remove("key4"));  //删除这个键值对

        //Map不能使用foreach循环,但是可以通过其他方法,有3个方法迭代Map

        // 方法1:Map的key,因为key不能重复,所以相当于Set:
        Set<String> keys=map.keySet(); //获取所有的key

        //获取了所有的key,又通过key了value
        for (String key:keys) {
            System.out.println(key+"->"+map.get(key));
        }

        //方法2:Map的Value
        Collection<Object> values=map.values();
        System.out.println(values);


        //方法3:键值对方式 EntrySet
        Set<Map.Entry<String,Object>> entrys=map.entrySet();
        for (Map.Entry<String,Object> entry:entrys) {
            System.out.println(entry.getKey()+"->"+entry.getValue());
        }


    }
}

 

总结,Set和Map的关系

 

 Map的图

 

HashMap没有排序,无序的

LinkedHashMap会根据你添加元素的顺序存储

TreeMap会有一个排序

 下面我们来通过一个例子,来讲解一下Map的使用

 

随意输入一个字符串,输出该字符串中每个字符所有的个数

package com.StadyJava.day16;
import java.util.*;

public class SetDemo {
    public static void main(String[] args) {

        String msg="asdhgsdhgasdkjhsa";

        //Map<Character,Integer> map=new HashMap<>();  没有顺序
        //Map<Character,Integer> map=new LinkedHashMap<>();   按照字符顺序
        Map<Character,Integer> map=new TreeMap<>();   //按照自然排序

        //先获取字符串的所有字符,转为char数组,字符串的底层就是char数组
        char[] chars=msg.toCharArray();

        for (char ch:chars) {
            if (map.containsKey(ch)) {
                //如果有这个字符了,就把value取出来,加1,再填进去
                Integer oldnum=map.get(ch);
                map.put(ch,oldnum+1);
            }
            else{
                map.put(ch,1);
            }
        }

        System.out.println(map);

    }
}

 

 List和Set和Map的选用

 

 

 List和Array数组和Map之间的转换

 

 Arrays转List得到的是一个固定长度的List,不能删除,可以更改

package com.StadyJava.day16;
import java.util.*;

public class SetDemo {
    public static void main(String[] args) {

        List<String> list=Arrays.asList("A","B","C");
        //list.remove(0); 报错 UnsupportedOperationException 因为Arrays.asList方法是把数组转化为一个固定长度的List
        list.set(0,"许嵩");
        System.out.println(list);
    }
}

 

 看看这个

package com.StadyJava.day16;
import java.util.*;

public class SetDemo {
    public static void main(String[] args) {

        List<Integer> list=Arrays.asList(1,2,3);
        int [] arr={1,2,3};
        List<int[]> list2=Arrays.asList(arr);
        System.out.println(list);
        System.out.println(list2);
    }
}

输出结果是

这个是因为asList方法后面是泛型,跟着的就是一个对象,例如Integer的就是1,2,3,这三个数字都是对象。但是下面那个int[]数组,数组也是一个对象。所以就出现了这种情况。

 

posted @ 2018-10-31 23:48  蜀云泉  阅读(297)  评论(0编辑  收藏  举报