weixin_45503872

java-集合

什么是算法和数据结构

【1】算法：

（1）可以解决具体问题 :例如 1+2+3+4+。。。+99+100

解题流程=算法

（2）有设计解决的具体的流程

算法1： 1+2=3 3+3=6 6+4=10.....加到100 --》5050

算法2：(1+100)*50=101*50=5050-->高斯算法

（3）有评价这个算法的具体的指标 --》时间复杂度空间复杂度（从数学角度考虑）

---------------------------------------------------------------------

【2】数据结构：就是在计算机的缓存，内存，硬盘如何组织管理数据的。重点在结构上，是按照什么结构来组织管理我们的数据。

数据结构分为：

（1）逻辑结构：--》思想上的结构--》卧室，厨房，卫生间 ---》线性表（数组，链表），图，树，栈，队列

（2）物理结构：--》真实结构--》钢筋混凝土+牛顿力学------》紧密结构（顺序结构），跳转结构（链式结构）

【3】紧密结构（顺序结构），跳转结构（链式结构）

以线性表为例：

线性表的逻辑结构如图所示：

线性表特点：

线性表是n个类型相同数据元素的有限序列，通常记作a0,a1,,,ai-1,ai,ai+1,,,,,an-1)。

1.相同数据类型

在线性表的定义中,我们看到从a0到an-1的n个数据元素是具有相同属件的亓素。

比如说可以都是数字,例如(12,23,45,56,45);

也可以是宇符,例如(A,B,....Z)

当然也可以是具有更复杂结构的数据元素,例如学生、商品、装备等。

相同数据类型意味着在内存中存储时,每个元素会占用相同的内存空间,便于后续的查询定位。

2.序列(顺序性)

在线性表的相邻数据元素之间存在若序偶关系，

即ai-1是ai的直接前驱,则ai是ai-1的直接后续,

同时ai又是ai+1的直接前驱，ai+1是ai的直接后续。

唯一没有直接前驱的元素a0 一端称为表头,唯一没有后续的元素an-1一端称为表尾。

除了表头和表尾元素外,任何一个元素都有且仅有一个直接前驱和直接后继。

3.有限

线件表中数据元素的个数n定义为线性表的长度, n是个有限值。

当n=0时线性表为空表，

在非空的线性表中每个数据元索在线性表中都有唯一确定的序号，

例如a0的序号是0 ,ai的序号是i。

在一个具有n>0个数据元素的线性表中,数据元素序号的范围是[O, n-1]。

逻辑结构和物理结构的关系：

线性表逻辑结构，对应的真实结构如果是紧密结构---》典型就是数组：

线性表逻辑结构，对应的真实结构如果是跳转结构---》典型就是链表：

优点：删除元素，插入元素效率高

缺点：查询元素效率低

集合的引入

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

PS:这里的存储指的是内存层面的存储，而不是持久化存储（.txt,.avi,.jpg,数据库）。

【2】数组：特点：

（1）数组一旦指定了长度，那么长度就被确定了，不可以更改。

int[] arr = new int[6];

（2）数组一旦声明了类型以后，数组中只能存放这个类型的数据。数组中只能

存放同一种类型的数据。

int[] arr,String[] s,double[] d.....

【3】数组：缺点：

（1）数组一旦指定了长度，那么长度就被确定了，不可以更改。

（2）删除，增加元素效率低。

（3）数组中实际元素的数量是没有办法获取的，没有提供对应的方法或者属性来获取

（4）数组存储：有序，可重复，对于无序的，不可重复的数组不能满足要求。

【4】正因为上面的缺点，引入了一个新的存储数据的结构---》集合

【5】集合一章我们会学习很多集合，为什么要学习这么多集合呢？

因为不同集合底层数据结构不一样。集合不一样，特点也不一样

简要集合结构图

集合应用场合

前端后端数据库交互：

当需要将相同结构的个体整合到一起的时候，需要集合。

实际应用场合：

Colletion接口

Colletion接口常用方法

1.package com.msb.test01;
2.
3.import java.util.ArrayList;
4.import java.util.Arrays;
5.import java.util.Collection;
6.import java.util.List;
7.
8./**
9. * @author : msb-zhaoss
10. */
11.public class Test01 {
12.    //这是main方法，程序的入口
13.    public static void main(String[] args) {
14.        /*
15.        Collection接口的常用方法：
16.        增加：add(E e) addAll(Collection c)
17.        删除：clear() remove(Object o)
18.        修改：
19.        查看：iterator() size()
20.        判断：contains(Object o)  equals(Object o) isEmpty()
21.         */
22.        //创建对象：接口不能创建对象，利用实现类创建对象：
23.        Collection col = new ArrayList();
24.        //调用方法：
25.        //集合有一个特点：只能存放引用数据类型的数据，不能是基本数据类型
26.        //基本数据类型自动装箱，对应包装类。int--->Integer
27.        col.add(18);
28.        col.add(12);
29.        col.add(11);
30.        col.add(17);
31.
32.        System.out.println(col/*.toString()*/);
33.
34.        List list = Arrays.asList(new Integer[]{11, 15, 3, 7, 1});
35.        col.addAll(list);//将另一个集合添加入col中
36.        System.out.println(col);
37.
38.        //col.clear();清空集合
39.        System.out.println(col);
40.        System.out.println("集合中元素的数量为："+col.size());
41.        System.out.println("集合是否为空："+col.isEmpty());
42.
43.        boolean isRemove = col.remove(15);
44.        System.out.println(col);
45.        System.out.println("集合中数据是否被删除："+isRemove);
46.
47.
48.        Collection col2 = new ArrayList();
49.        col2.add(18);
50.        col2.add(12);
51.        col2.add(11);
52.        col2.add(17);
53.
54.        Collection col3 = new ArrayList();
55.        col3.add(18);
56.        col3.add(12);
57.        col3.add(11);
58.        col3.add(17);
59.
60.        System.out.println(col2.equals(col3));
61.        System.out.println(col2==col3);//地址一定不相等  false
62.
63.        System.out.println("是否包含元素："+col3.contains(117));
64.
65.    }
66.}

Collection集合的遍历

迭代器简要原理图：

1.package com.msb.test01;
2.
3.import java.util.ArrayList;
4.import java.util.Collection;
5.import java.util.Iterator;
6.
7./**
8. * @author : msb-zhaoss
9. */
10.public class Test02 {
11.    //这是main方法，程序的入口
12.    public static void main(String[] args) {
13.        Collection col = new ArrayList();
14.        col.add(18);
15.        col.add(12);
16.        col.add(11);
17.        col.add(17);
18.        col.add("abc");
19.        col.add(9.8);
20.
21.        //对集合遍历（对集合中元素进行查看）
22.        //方式1：普通for循环
23.        /*for(int i= 0;i


List接口

List接口的常用方法和遍历方式
1.package com.msb.test01;
2.
3.import com.sun.org.apache.xerces.internal.dom.PSVIAttrNSImpl;
4.
5.import java.util.ArrayList;
6.import java.util.Iterator;
7.import java.util.List;
8.
9./**
10. * @author : msb-zhaoss
11. */
12.public class Test03 {
13.    //这是main方法，程序的入口
14.    public static void main(String[] args) {
15.        /*
16.        List接口中常用方法：
17.        增加：add(int index, E element)
18.        删除：remove(int index)  remove(Object o)
19.        修改：set(int index, E element)
20.        查看：get(int index)
21.        判断：
22.         */
23.        List list = new ArrayList();
24.        list.add(13);
25.        list.add(17);
26.        list.add(6);
27.        list.add(-1);
28.        list.add(2);
29.        list.add("abc");
30.        System.out.println(list);
31.        list.add(3,66);
32.        System.out.println(list);
33.        list.set(3,77);
34.        System.out.println(list);
35.        list.remove(2);//在集合中存入的是Integer类型数据的时候，调用remove方法调用的是：remove(int index)
36.        System.out.println(list);
37.        list.remove("abc");
38.        System.out.println(list);
39.
40.        Object o = list.get(0);
41.        System.out.println(o);
42.
43.        //List集合 遍历：
44.        //方式1：普通for循环：
45.        System.out.println("---------------------");
46.        for(int i = 0;i

ArrayList实现类（JDK1.7）
【1】在idea中切换JDK的方法：

【2】ArrayList实现List接口的失误：
集合创始人 承认了这个失误，但是在后续的版本中没有删除，觉得没必要：

【3】底层重要属性：

在JDK1.7中：在调用构造器的时候给底层数组elementData初始化，数组初始化长度为10：

对应内存：

调用add方法：

1.  ArrayList al = new ArrayList();
2.
3.        System.out.println(al.add("abc"));
        System.out.println(al.add("def"));
当数组中的10个位置都满了的时候就开始进行数组的扩容，扩容长度为 原数组的1.5倍：




ArrayList实现类（JDK1.8）
【1】JDK1.8底层依旧是Object类型的数组，size:数组中有效长度：

【2】ArrayList al = new ArrayList();调用空构造器：

【2】add方法：





Vector实现类
【1】底层Object数组，int类型属性表示数组中有效长度：


【2】Vector v=new Vector();调用构造器：

【3】add方法：

泛型
引入
【1】什么是泛型（Generic）：
泛型就相当于标签
形式：<>  
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，
JDK1.5之 后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。
Collection, List， ArrayList 这个就是类型参数，即泛型。

【2】没有泛型的时候使用集合：
1.package com.msb.test01;
2.
3.import java.util.ArrayList;
4.
5./**
6. * @author : msb-zhaoss
7. */
8.public class Test01 {
9.    //这是main方法，程序的入口
10.    public static void main(String[] args) {
11.        //创建一个ArrayList集合，向这个集合中存入学生的成绩：
12.        ArrayList al = new ArrayList();
13.        al.add(98);
14.        al.add(18);
15.        al.add(39);
16.        al.add(60);
17.        al.add(83);
18.        al.add("丽丽");
19.
20.        //对集合遍历查看：
21.        for(Object obj:al){
22.            System.out.println(obj);
23.        }
24.    }
25.}
如果不使用泛型的话，有缺点：
一般我们在使用的时候基本上往集合中存入的都是相同类型的数据--》便于管理，所以现在什么引用数据类型都可以存入集合，不方便！

【3】JDK1.5以后开始使用泛型，集合中使用泛型：
1.package com.msb.test01;
2.
3.import java.util.ArrayList;
4.
5./**
6. * @author : msb-zhaoss
7. */
8.public class Test01 {
9.    //这是main方法，程序的入口
10.    public static void main(String[] args) {
11.        //创建一个ArrayList集合，向这个集合中存入学生的成绩：
12.        //加入泛型的优点：在编译时期就会对类型进行检查，不是泛型对应的类型就不可以添加入这个集合。
13.        ArrayList al = new ArrayList();
14.        al.add(98);
15.        al.add(18);
16.        al.add(39);
17.        al.add(60);
18.        al.add(83);
19.        /*al.add("丽丽");
20.        al.add(9.8);*/
21.
22.        //对集合遍历查看：
23.        /*for(Object obj:al){
24.            System.out.println(obj);
25.        }*/
26.        for(Integer i:al){
27.            System.out.println(i);
28.        }
29.    }
30.}
【4】泛型总结：
（1）JDK1.5以后
（2）泛型实际就是 一个<>引起来的 参数类型，这个参数类型  具体在使用的时候才会确定具体的类型。 


（3）使用了泛型以后，可以确定集合中存放数据的类型，在编译时期就可以检查出来。
（4）使用泛型你可能觉得麻烦，实际使用了泛型才会简单，后续的遍历等操作简单。
（5）泛型的类型：都是引用数据类型，不能是基本数据类型。
（6）ArrayList al = new ArrayList();在JDK1.7以后可以写为：
ArrayList al = new ArrayList<>();  --<>  ---钻石运算符
自定义泛型结构

泛型类，泛型接口
【1】泛型类的定义和实例化：
1.package com.msb.test02;
2.
3./**
4. * @author : msb-zhaoss
5. * GenericTes就是一个普通的类
6. * GenericTest 就是一个泛型类
7. * <>里面就是一个参数类型，但是这个类型是什么呢？这个类型现在是不确定的，相当于一个占位
8. * 但是现在确定的是这个类型一定是一个引用数据类型，而不是基本数据类型
9. */
10.public class GenericTest {
11.    int age;
12.    String name;
13.    E sex;
14.
15.    public void a(E n){
16.
17.    }
18.    public void b(E[] m){
19.
20.    }
21.}
22.
23.class Test{
24.    //这是main方法，程序的入口
25.    public static void main(String[] args) {
26.        //GenericTest进行实例化：
27.        //(1)实例化的时候不指定泛型：如果实例化的时候不明确的指定类的泛型，那么认为此泛型为Object类型
28.        GenericTest gt1 = new GenericTest();
29.        gt1.a("abc");
30.        gt1.a(17);
31.        gt1.a(9.8);
32.        gt1.b(new String[]{"a","b","c"});
33.
34.        //（2）实例化的时候指定泛型：---》推荐方式
35.        GenericTest gt2 = new GenericTest<>();
36.        gt2.sex = "男";
37.        gt2.a("abc");
38.        gt2.b(new String[]{"a","b","c"});
39.        
40.    }
41.}
【2】继承情况：
（1）父类指定泛型
1.class SubGenericTest extends GenericTest{
2.
3.}
4.
5.class Demo{
6.    //这是main方法，程序的入口
7.    public static void main(String[] args) {
8.        //指定父类泛型，那么子类就不需要再指定泛型了，可以直接使用
9.        SubGenericTest sgt = new SubGenericTest();
10.        sgt.a(19);
11.    }
12.}
（2）父类不指定泛型：
如果父类不指定泛型，那么子类也会变成一个泛型类，那这个E的类型可以在创建子类对象的时候确定：
1.class SubGenericTest2 extends GenericTest{
2.
3.}

1.class Demo2{
2.    //这是main方法，程序的入口
3.    public static void main(String[] args) {
4.        SubGenericTest2 s = new  SubGenericTest2<>();
5.        s.a("abc");
6.        s.sex = "女";
7.    }
8.}
【3】应用场合：

【4】细节：
（1）泛型类可以定义多个参数类型

（2）泛型类的构造器的写法：

（3）不同的泛型的引用类型不可以相互赋值：

（4）泛型如果不指定，那么就会被擦除，反应对应的类型为Object类型：

（5）反省类中的静态方法不能使用类的泛型：

（6）不能直接使用E[]的创建：

泛型方法
1.package com.msb.test04;
2.
3./**
4. * @author : msb-zhaoss
5. * 1.什么是泛型方法：
6. * 不是带泛型的方法就是泛型方法
7. * 泛型方法有要求：这个方法的泛型的参数类型要和当前的类的泛型无关
8. * 换个角度：
9. * 泛型方法对应的那个泛型参数类型 和  当前所在的这个类 是否是泛型类，泛型是啥  无关
10. * 2.泛型方法定义的时候，前面要加上
11. *     原因：如果不加的话，会把T当做一种数据类型，然而代码中没有T类型那么就会报错
12. * 3.T的类型是在调用方法的时候确定的
13. * 4.泛型方法可否是静态方法？可以是静态方法
14. */
15.public class TestGeneric {
16.    //不是泛型方法 （不能是静态方法）
17.    public static void a(E e){
18.
19.    }
20.    //是泛型方法
21.    public static   void b(T t){
22.
23.    }
24.
25.}
26.class Demo{
27.    //这是main方法，程序的入口
28.    public static void main(String[] args) {
29.        TestGeneric tg = new TestGeneric<>();
30.        tg.a("abc");
31.        tg.b("abc");
32.        tg.b(19);
33.        tg.b(true);
34.    }
35.}
36.
泛型参数存在继承关系的情况

通配符
【1】在没有通配符的时候：
下面的a方法，相当于方法的重复定义，报错
1.public class Test {
2.    /*public void a(List