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中引入的特性，它提供了编译时类型安全检测机制
- 泛型可以使用的地方： 类后面-----》泛型类 方法声明上---------》泛型方法 接口后面-------》泛型接口
-
泛型的好处
-
把运行时期的问题提前到了编译期间
-
避免了强制类型转换
-
-
泛型的定义格式
-
<类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <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>,表示这个类是一个泛型类
创建泛型类的对象时，必须要给这个泛型确定具体的数据类型
-
定义格式
修饰符 <类型> 返回值类型 方法名(类型 变量名) { } - 范例：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);
}
package com.itheima.genericitinterface;
public class GenericityImpl1<E> implements Genericity<E>{
@Override
public void method(E e) {
System.out.println(e);
}
}
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所有的子类，规定了上边界