Week03_day05 集合（下）

一、List的实现类

ArrayList和LinkedList 选用哪一个：

查询多：用ArrayList

增删多：LinkedList

2.LinkedList

底层是双向链表结构。

特点：有下标 查询慢 增删快

方法：

void addFirst(E e)

将指定元素插入此列表的开头。

void addLast(E e)

将指定元素添加到此列表的结尾。

boolean offerFirst(E e)

在此列表的开头插入指定的元素。

boolean offerLast(E e)

在此列表末尾插入指定的元素。

E removeFirst()

移除并返回此列表的第一个元素。

E removeLast()

移除并返回此列表的最后一个元素。

E getFirst()

返回此列表的第一个元素。

E getLast()

返回此列表的最后一个元素。

实例：

public class DemoLinkedList {public static void main(String[] args) {LinkedList list=new LinkedList();list.add("孙猴子");list.add("如来佛祖");list.add("德玛西亚");list.addFirst("1111");list.addLast("9999");System.out.println(list.getFirst());System.out.println(list.getLast());System.out.println("删除第一个："+list.removeFirst());System.out.println("删除最后一个："+list.removeLast());list.offerFirst("嘤嘤~~~");System.out.println(list);}}

3、ArrayList和逆序遍历方法

List list=new ArrayList(9);//初始长度是10  每次扩容到1.5倍长度。ListIterator it = list.listIterator();int i=0;while(it.hasNext()){Object next = it.next();if(next.equals("印度阿小三")){it.add("木棍~~~");}if(next.equals("牛魔王")){//it.set("铁扇公主");}if(next.equals("奥巴马")){//it.remove();}/*it.add(i);i++;*/}System.out.println(list);/** * 逆序遍历 */System.out.println("逆序输出：");while(it.hasPrevious()){Object previous = it.previous();System.out.print(previous+"\t");}

4.vector

用法和ArrayList一样 只不过是线程安全的 synchronized

5.Stack：栈

先进后出 后进先出

栈特有的方法：

boolean empty() 测试堆栈是否为空。

E peek() 查看堆栈顶部的对象，但不从堆栈中移除它。

E pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。

E push(E item) 把项压入堆栈顶部。

int search(Object o) 返回对象在堆栈中的位置，以 1 为基数。 栈顶是1

栈可以用父接口的方法，但是只有用栈的方法的时候才能叫栈

实例：

public class DemoStack {public static void main(String[] args) {Stack  s=new Stack();s.push("小苍老师");s.push("XXX老师");s.push("AAA老师");s.push("OOO老师");//最后一个加的是栈顶s.push("小英老师");System.out.println(s.pop());System.out.println(s.peek());//看一下System.out.println(s);System.out.println(s.search("小苍老师"));}}

---

二、Queue（队列）

实现类：LinkedList

特点：先进先出，后进后出

特有方法：

boolean offer(E e)

将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)， 后者可能无法插入元素，而只是抛出一个异常。

E peek()

获取但不移除此队列的头；如果此队列为空，则返回 null。

E poll()

获取并移除此队列的头，如果此队列为空，则返回 null。

实例：

public class DemoQueue {public static void main(String[] args) {Queue q=new LinkedList();q.offer("孙猴子");q.offer("死肥猪");q.offer("沙悟净");q.offer("死秃驴");int size = q.size();System.out.println(size);for(int i=0;i<size;i++){q.poll();}/*q.poll();//出队System.out.println(q.peek());*/System.out.println(q);}}

---

三、泛型：用来对数据类型做约束的

1.泛型和集合类一起使用

2.泛型和方法一起使用 泛型方法

3.泛型和自定义类一起使用 自定义泛型类

4.泛型和自定义接口一起使用 自定义泛型接口

5.泛型的通配符? 和泛型上下限

1.集合只能存储某一类型 就得用泛型给集合做约束 推荐使用泛型

List<Cat> list=new ArrayList<>();

泛型<>只能写类List<Integer> list1=new ArrayList<>();

例如：

public class DemoFx1 {public static void main(String[] args) {//List<Cat> list=new ArrayList<Cat>();   两种写法都可以List<Cat> list=new ArrayList<>();//Stack<Dog> s=new Stack<>();/*list.add(new Dog());*/list.add(new Cat("小花"));list.add(new Cat("小黑"));list.add(new Cat("小黄"));for(int i=0;i<list.size();i++){Cat c = list.get(i);System.out.println(c);}}}

2.泛型方法

public class DemoFX2 {public static void main(String[] args) {/** * 泛型方法调用的时候  传具体的类型 */int x=say(1,"hallo",333);System.out.println(1);}/** * 泛型方法 * 任意大写字母： 表示任意数据类型  * @param <T> */public static  <T,A> T   say(T t,A a,T b){System.out.println("泛型方法");return t;}public  void  say(Object o){//多态}}

3.自定义泛型类

当该类用到自定义泛型的时候 需要在该类头部声明该泛型

格式：修饰符 class 类名<泛型>{ }

注：在自定义 泛型类里面 是不能写泛型数组；（指的是可以引用，不能new泛型数组）

在自定义 泛型类里面 是不能写泛型常量；

在自定义 泛型类里面 是不能写静态泛型属性或者方法；

//创建对象的时候 不指定类的泛型 默认是Object类型

Student s=new Student<>();

//创建对象的时候 指定类型

Student<String> s1=new Student<>();

s1.say("ssss");

/** * 自定义泛型类 * @author Serendipity * * @param <T> */public class Student <T> {public static void main(String[] args) {//创建对象的时候  不指定类的泛型   默认是Object类型Student s=new Student<>();  //s默认是object类型//创建对象的时候  指定类型Student<String> s1=new Student<>();s1.say("ssss");}private T t;//成员变量private T[] arr;//private T[] arr1;//=new T[100];//private final T=new T();//private static  T  tt; 在自定义 泛型类里面  是不能写静态泛型属性或者方法public T getT() {return t;}public Student() {super();// TODO Auto-generated constructor stub}public Student(T t, T[] arr) {super();this.t = t;this.arr = arr;}public void setT(T t) {this.t = t;}public T[] getArr() {return arr;}public void setArr(T[] arr) {this.arr = arr;}public   void   say(T t){System.out.println("泛型方法");}public   void   say1(T t){}}

在继承中：

public abstract class Fu <T> {abstract void  say(T t); }//父类是泛型类  子类没指定  默认泛型是Objectclass Zi  extends Fu{@Overridevoid say(Object t) {// TODO Auto-generated method stub}}//父类是泛型类  子类此时的泛型类型不确定  子类也得是泛型类class Zi1<T>  extends Fu<T>{@Overridevoid say(T t) {// TODO Auto-generated method stub}}//子类确定了类型    这种用的多class Zi2  extends Fu<Zi2>{@Overridevoid say(Zi2 t) {// TODO Auto-generated method stub}}

4.泛型和自定义接口一起使用

package com.serendipity.fanxing.iters;public interface Inter<T> {void   say(T t);}//不指定  默认Objectclass InterImpl1  implements Inter{@Overridepublic void say(Object t) {// TODO Auto-generated method stub}}//接口指定了泛型类 实现类的泛型类不指定  实现类也得是泛型类class InterImpl2<T>  implements Inter<T>{@Overridepublic void say(T t) {// TODO Auto-generated method stub}}//实现类确定了类型    这种用的多class InterImpl3 implements Inter<InterImpl3>{@Overridepublic void say(InterImpl3 t) {// TODO Auto-generated method stub}}

5.泛型的通配符? 和泛型上下限

泛型上下限

泛型的上限：

List<? extends Number> list:

可以传 List<Number> numList=new ArrayList<>();

List<Integer> intList=new ArrayList<>();

泛型的下限：

List<? super Integer> list:

可以传Integer 或者 Integer的父类 Integer是最小的类型

import java.util.ArrayList;import java.util.List;public class Demo {public static void main(String[] args) {List<String> list=new ArrayList<>();List<Number> numList=new ArrayList<>();List<Integer> intList=new ArrayList<>();//say3(numList);    //可以         //say3(intList);   //不可以     Number类say4(numList);say4(intList);say5(numList);say5(intList);}public  void  sss(Number num){//Number是Interger(包装类)的父类   这才叫多态}    public static   void  say5(List<? super Integer> list){    //想接受Number的泛型List 和Ingeger泛型的ListSystem.out.println(list);}public static   void  say4(List<? extends Number> list){//想接受Number的泛型List 和Ingeger泛型的ListSystem.out.println(list);}public static   void  say3(List<Number> list){//想接受Number的泛型List 和Ingeger泛型的ListSystem.out.println(list);}public static   void  say2(List<?> list){System.out.println(list);}public   void  say1(List<Object> list){}public  <T> void  say(List<T> list){}}

---

四、set:无序的(存的顺序和取得顺序不一致)、没有下标、不能存储重复元素

1. HashSet: 哈希表 又叫散列表。底层使用HashMap来实现。数组来实现的。

实例默认初始容量是16

存储自定义对象的时候：对象的类型一样 属性全都一样 我们认为是同一个对象 不让存储，这时候需要重写 hashCode和equals方法

public class DemoSet {public static void main(String[] args) {Set<String> set=new HashSet<String>();set.add("野猴子");set.add("野猴子");set.add("野猴子1");Set catSet=new HashSet<>();catSet.add(new Cat("小花","花色",1));catSet.add(new Cat("小黑","黑色",1));catSet.add(new Cat("小白","白色",1));catSet.add(new Cat("小白","白色",1));catSet.add(new DOg("小白","白色",1));System.out.println(catSet);//4   3   System.out.println(set);}}

输入一个元素，如何确定它在集合中的位置？

比如：输入一个"hahahh" 需要先用hashCode方法=====>hash值=====>hash算法来确定位置

判断重复：先调用hashCode()方法，判断hash值是否一样，如果hash值不一样，肯定不相同；

如果hash值一样，继续调用equals方法，equals返回true，表明重复了，不存了。

2.LinkedHashSet：底层是LinkedHashMap

3.TreeSet：结构很稳定

、

注意：java.lang.ClassCastException: com.qf.set.Cat cannot be cast to java.lang.Comparable

TreeSet存储自定义对象的时候 自定义对象的类要实现java.lang.Comparable，并且重写 compareTo方法，来指定自定义排序规则

public class DemoTreeSet {public static void main(String[] args) {TreeSet  ts=new TreeSet();ts.add("ahaha");ts.add("嘿嘿嘿");ts.add("嗷嗷嗷");ts.add("啊啊啊");ts.add("啊啊奥");ts.add("哎哎哎");/** *  java.lang.ClassCastException: com.qf.set.Cat cannot be cast to java.lang.Comparable */TreeSet<Cat>  ts1=new TreeSet<Cat>();ts1.add(new Cat("aaa小asdads花","花",1));ts1.add(new Cat("bbb小adsad花","花",2));ts1.add(new Cat("ccc小asdagth黄","花",2));ts1.add(new Cat("ccc小asdagth花","花",4));ts1.add(new Cat("ccc小asdagth花","花",4));ts1.add(new Cat("ddd小12313花","花",3));System.out.println(ts1);}}

public class Cat implements Comparable<Cat>{private  String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Cat [name=" + name + ", age=" + age + "]";}public Cat(String name, int age) {super();this.name = name;this.age = age;}public Cat() {super();// TODO Auto-generated constructor stub}@Overridepublic int compareTo(Cat o) {// TODO Auto-generated method stubreturn this.age-o.getAge()==0? 1:this.age-o.getAge() ;}