25.数据结构，LinkedList ，泛型，类型通配符

3.数据结构

数据结构是计算机存储，组织数据的方式。是指相互之间存在的一种或多种特定关系的数据元素的集合

通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

---------常见的数据结构之栈

数据进入栈模型的过程称为：压/进栈

数据离开栈模型的过程称为：弹/出栈

栈是一种数据先进后厨的模型

---------常见的数据结构之队列

数据从后端进入队列模型的过程称为：入队列

数据从前端离开队列模型的过程称为：出队列

3.1数据结构之栈和队列【记忆】

• 栈结构

  先进后出

• 队列结构

  先进先出

3.2数据结构之数组和链表【记忆】

---------常见的数据结构之数组

数组是一种查询快，增删慢的模型

查询数据通过地址值和索引定位，查询任意数据耗时相同，查询速度快

删除数据时，要将原始数据删除，同时后面的每个数据前移，删除效率低

添加数据时，添加位置后的每个数据后移，在添加元素，添加效率极低

---------常见的数据结构之链表

链表是一种增删快的模型（对比数组）

链表是一种查询慢的模型（对比数组）

查询数据D是否存在，必须从头（head）开始查询

查询第N个数据，必须从头（head）开始查询

• 数组结构

  查询快、增删慢

• 队列结构

  查询慢、增删快

4.List集合的实现类

4.1List集合子类的特点【记忆】

• ArrayList集合

  底层是数组结构实现，查询快、增删慢

• LinkedList集合

  底层是链表结构实现，查询慢、增删快

package com.itheima.mylistdemo1;

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

public class MyLinkedListDemo3 {
    public static void main(String[] args) {
        LinkedList<String> list=new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("----------------");
        Iterator<String> it=list.listIterator();
        while (it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }
        System.out.println("----------------");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

　　

4.2LinkedList集合的特有功能【应用】

• 特有方法

  方法名	说明
  public void addFirst(E e)	在该列表开头插入指定的元素
  public void addLast(E e)	将指定的元素追加到此列表的末尾
  public E getFirst()	返回此列表中的第一个元素
  public E getLast()	返回此列表中的最后一个元素
  public E removeFirst()	从此列表中删除并返回第一个元素
  public E removeLast()	从此列表中删除并返回最后一个元素

package com.itheima.mylistdemo1;

import java.util.LinkedList;

public class MyLinkedListDemo4 {
    public static void main(String[] args) {
        LinkedList<String> list=new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //method1(list);
        //method2(list);
       //method3(list);
        method4(list);

    }

    public static void method4(LinkedList<String> list) {
        //public E removeFirst()	从此列表中删除并返回第一个元素
        //public E removeLast()	从此列表中删除并返回最后一个元素
        String first = list.removeFirst();
        String last = list.removeLast();
        System.out.println(first);
        System.out.println(last);
        System.out.println(list);
    }

    public static void method3(LinkedList<String> list) {
        //public E getFirst()	返回此列表中的第一个元素
        //public E getLast()	返回此列表中的最后一个元素
        String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first);
        System.out.println(last);
    }

    public static void method2(LinkedList<String> list) {
        //public void addLast(E e)	将指定的元素追加到此列表的末尾
        list.addLast("www");
        System.out.println(list);
    }

    public static void method1(LinkedList<String> list) {
        //public void addFirst(E e)	在该列表开头插入指定的元素
        list.addFirst("sss");
        System.out.println(list);
    }

}

　　双向链表实现　　，查询如果离头近就从头开始查 ，如果离尾近就行尾部往前查

5.泛型

5.1泛型概述【理解】

• 泛型的介绍

  泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制

• 泛型可以使用的地方： 类后面-----》泛型类      方法声明上---------》泛型方法        接口后面-------》泛型接口

• 泛型的好处

  1. 把运行时期的问题提前到了编译期间

  2. 避免了强制类型转换

• 泛型的定义格式

  • <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <E> <T><Q><M>

  • <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>

5.2泛型类【应用】

• 定义格式

  修饰符 class 类名<类型> {  }

• 示例代码

泛型类

public class Generic<T> {  //此处T可以随便写为任意标识，常见的如T,E,K,V 等形式的参数常用于表示泛型
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

测试类

public class GenericDemo1 {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<String>();
        g1.setT("杨幂");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(30);
        System.out.println(g2.getT());

        Generic<Boolean> g3 = new Generic<Boolean>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}

　　总结：

如果一个类的后面又<E>,表示这个类是一个泛型类

创建泛型类的对象时，必须要给这个泛型确定具体的数据类型

5.3泛型方法【应用】

• 定义格式

  修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }

• 范例：public <T> void show(T t){    }               被调用的时候才会有具体的类型

• 示例代码

  • 带有泛型方法的类

package com.itheima.genericityMethod1;

import java.util.ArrayList;
import java.util.Arrays;

/*
* 使用java中的泛型方法
* */
public class GenericityMethod1 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("给小李");
        list.add("给小张");
        list.add("给小王");
        //将list集合转成一个数组 并返回
        //如果是空参的，那么返回的数组类型为Object类型的
        Object[] objects = list.toArray();
        System.out.println(Arrays.toString(objects));

        String[] strings = list.toArray(new String[list.size()]);
        System.out.println(Arrays.toString(strings));
    }

}

　　练习：定义一个泛型方法，传递一个集合和四个元素，将元素添加到集合中并返回　　

package com.itheima.genericityMethod1;

import java.util.ArrayList;

/**
 *     自定义泛型方法
 * 　　练习：定义一个泛型方法，传递一个集合和四个元素，将元素添加到集合中并返回　　
 *
 * */
public class GenericityMethod2 {
    public static void main(String[] args) {
        ArrayList<String> list1 = addElement(new ArrayList<String>(), "a", "b", "c", "d");
        System.out.println(list1);

        ArrayList<Integer> list2 = addElement(new ArrayList<Integer>(), 1, 2, 3, 4);
        System.out.println(list2);

    }

    public static <T>ArrayList<T> addElement(ArrayList<T> list,T t1,T t2,T t3,T t4){
        list.add(t1);
        list.add(t2);
        list.add(t3);
        list.add(t4);
        return list;
    }
}

　

5.4泛型接口【应用】

泛型接口的使用方式：

　　实现类也不给泛型

　　实现类确定具体的数据类型

• 定义格式

  修饰符 interface 接口名<类型> {  }

• 示例代码

  • 泛型接口

    public interface Generic<T> {
        void show(T t);
    }

  • 泛型接口实现类1

    定义实现类时,定义和接口相同泛型,创建实现类对象时明确泛型的具体类型

　

泛型接口：

package com.itheima.genericitinterface;

public interface Genericity<E> {
    public abstract void method(E e);
}

泛型接口实现类1

定义实现类时,定义和接口相同泛型,创建实现类对象时明确泛型的具体类型

package com.itheima.genericitinterface;

public class GenericityImpl1<E> implements Genericity<E>{

    @Override
    public void method(E e) {
        System.out.println(e);
    }
}

泛型接口实现类2

定义实现类时,直接明确泛型的具体类型

package com.itheima.genericitinterface;

public class GenericityImpl2 implements Genericity<Integer>{
    @Override
    public void method(Integer integer) {
        System.out.println(integer);
    }
}

测试类

package com.itheima.genericitinterface;

public class GenericityInterface {
    public static void main(String[] args) {
        GenericityImpl1<String> genericity=new GenericityImpl1<>();
        genericity.method("小李给我的");

        GenericityImpl2 genericityImpl2=new GenericityImpl2();
        genericityImpl2.method(16);
    }
}

5.5类型通配符

• 类型通配符: <?>

  • ArrayList<?>: 表示元素类型未知的ArrayList,它的元素可以匹配任何的类型

  • 但是并不能把元素添加到ArrayList中了,获取出来的也是父类类型

• 类型通配符上限: <? extends 类型>

  • ArrayListList <? extends Number>: 它表示的类型是Number或者其子类型

• 类型通配符下限: <? super 类型>

  • ArrayListList <? super Number>: 它表示的类型是Number或者其父类型

• 泛型通配符的使用

　　？super Number

　　　　Number和Number所有的父类，规定了下边界

规定的类型（Number）

　　？extends Number

　　　　Number和Number所有的子类，规定了上边界