大数据预科班14

复习

• 异常

1. 顶级父类Throwable：Error，Exception2. Exception：编译时异常、运行时异常3. 自定义异常4. 异常的捕获和处理--多catch；同一父类；分组。5. finally控制语句（return，throw，break，continue）之前

集合

• 顶级集合Collection：容器、大小不定--泛型
• List

1. 有序2. 可重复

• ArrayList

1. 基于数组2. 默认容量为10，每次扩容上一次的一半；内存空间连续3. 增删元素较慢--移动元素4. 查询较快--下标5. 线程不安全6. 展示--查询居多时

Vector

• 基于数组
• 初始大小：10
• 扩容：每次扩容一倍，内存空间连续
• 增删较慢，查询较快
• 线程安全
• java的最早的集合
• 原生elementAt==get等
• elements返回值为Enumeration，本质为迭代器

Enumeration<String> en=v.elements();//判断后续是否还有元素while(en.hasMoreElements){    //挪动指针指向下一个元素    String s=en.nextElement();    System.out.print(s);}

• 注：迭代删除时--跳跃删除（指针移动的同时，数组也移动）

Stack

• 栈：先进后出
• 将元素放入栈中：压栈/入栈
• 将元素取出：弹栈/出栈
• 最先放入栈中的元素--栈底元素
• 最后放入栈中的元素--栈顶元素
• 基于数组（继承Vector）
• 方法

1. 入栈--push（存正常存【打印时按存的顺序】，取倒着取）2. 出栈--pop（取出并弹出）3. 获取栈顶元素并不移除--peek4. 判断栈空empty5. search（o）返回元素在栈中出现的位置--栈顶向栈底查找（基数为1）

练习

• 1. 用Vector实现Stack

package com.peng.demo;import java.util.EmptyStackException;import java.util.Vector;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JPanel;public class Testq {    public static void main(String[] args) {        Testq t = new Testq();        t.push("a");        t.push("b");        t.push("c");        t.push("d");        System.out.println(t.pop());        System.out.println(t);    }    // 用Vector实现Stack    Vector<String> v = new Vector<String>();    boolean empty() {        if (v.isEmpty()) {            return true;        } else {            return false;        }    }    String peek() {        if (v.size() <= 0) {            throw new EmptyStackException();        }        return v.get(v.size() - 1);    }    String pop() {        if (v.size() <= 0) {            throw new EmptyStackException();        }        String temp = v.get(v.size() - 1);        v.remove(v.size() - 1);        return temp;    }    String push(String s) {        v.add(s);        return s;    }    int search(String s) {        return v.size() - v.indexOf(s);    }    public String toString() {        StringBuilder sb = new StringBuilder();        for (int i = 0; i < v.size(); i++) {            sb.append(v.get(i) + ",");        }        return sb.toString().substring(0, sb.toString().length() - 1);    }}

• 2. 用数组实现Stack

package com.peng.demo;import java.util.Arrays;import java.util.EmptyStackException;/* * 数组实现Stack */public class Test3 {    String[] arr = new String[10];    int size = 0;    String pop() {        // 判空        if (size <= 0) {            throw new EmptyStackException();        } else {            String temp = arr[size - 1];            size--;            return temp;        }    }    String peek() {        // 判空        if (size <= 0) {            throw new EmptyStackException();        } else {            String temp = arr[size - 1];            return temp;        }    }    void push(String s) {        // 判断是否需要扩容        if (size >= arr.length) {            // 扩容            arr = Arrays.copyOf(arr, arr.length * 2);        }        arr[size] = s;        size++;    }    int search(String s) {        for (int i = 0; i < size; i++) {            if (arr[i] == s || s != null && arr[i].equals(s)) {                return size - 1 - i + 1;            }        }        return -1;    }    boolean empty() {        if (size == 0) {            return true;        } else {            return false;        }    }    public static void main(String[] args) {        Test3 t = new Test3();        t.push("a");        t.push("b");        t.push("c");        System.out.println(t.pop());        System.out.println(t.peek());        System.err.println(t.size);    }}

LinkedList

• 基于链表
• 内存空间不连续
• 增删元素较快
• 查询较慢
• 线程不安全
• 购物车--增删频繁

1. 节点->节点对象->节点类（Node）2. 属性：上一个节点（Node）；存储数据（String）；下一个节点（Node）；3. 方法：允许获取和设置数据getter/setter4. 头结点、尾节点、节点个数

练习

• java实现LinkedList

package com.peng.demo;/* * 操作节点的类 */public class LinkedListDemo {    private Node first;// 头结点    private Node last;// 尾结点    private int size;// 结点个数    // 构造函数    public LinkedListDemo() {    }    // 添加节点方法    public void add(String s) {        // 如果头结点为空，则指向头结点        if (first == null) {            this.first = new Node(null, s, null);            // 因为只有一个结点，所以尾节点指向头结点，表示同一个            this.last = this.first;        } else {            // 如果不是头结点，新节点指向原来的尾节点            Node node = new Node(this.last, s, null);            this.last.next = node;            this.last = node;        }        size++;    }    // 指定位置添加新的节点    public void add(int index, String s) {        // 判断下标越界        if (index > size) {            throw new IndexOutOfBoundsException("Index:" + index + ",Size:"                    + size);        } else if (0 == index) {            // 插到头结点            Node node = new Node(null, s, this.first);            this.first.prev = node;            this.first = node;            size++;        } else if (index == size) {            // 插到末尾            this.add(s);        } else {            // 插到中间位置            Node temp = this.first;            for (int i = 0; i <= index - 1; i++) {                // 目标位置上的节点                temp = temp.next;            }            // 目标位置的上一个节点            Node prev = temp.prev;            // 要插入的节点            Node insertNode = new Node(prev, s, temp);            // 将目标位置的上一个节点变成当前节点            prev.next = insertNode;            // 将该位置的原先节点的上一位换为要插入的节点            temp.prev = insertNode;            size++;        }    }    // 移除节点方法    public void remove(int index) {        // 判断下标越界        if (index >= size) {            throw new IndexOutOfBoundsException("Index:" + index + ",Size:"                    + size);        }        if (index == 0) {            this.first = this.first.next;            this.first.prev = null;        } else if (index == size - 1) {            this.last = this.last.prev;            this.last.next = null;        } else {            // 记录要找的节点            Node node = this.first;            for (int i = 0; i < index; i++) {                node = node.next;            }            // 获取上一个节点和下一个节点            Node prev = node.prev;            Node next = node.next;            // 把上一节点的下一位改为下一个节点            prev.next = next;            // 把下一节点的上一位=改为上一个节点            next.prev = prev;        }        size--;    }    // 获取节点下标的方法    public int indexOf(String s) {        Node node = this.first;        for (int i = 0; i < size; i++) {            if (node.data == s || s != null && s.equals(node.data)) {                return i;            }            node = node.next;        }        return -1;    }    // 打印方法    public String toString() {        StringBuilder sb = new StringBuilder("[");        Node node = this.first;        for (int i = 0; i < size; i++) {            sb.append(node.data).append(", ");            node = node.next;        }        String str = sb.toString();        if (str.length() > 1) {            str = str.substring(0, str.length() - 2);        }        return str + "]";    }    // ---------------------内部类----------------------------    private class Node {        Node prev;// 上一个节点        String data;// 数据        Node next;// 下一个节点        // 构造函数        public Node(Node prev, String data, Node next) {            super();            this.prev = prev;            this.data = data;            this.next = next;        }        // 获取数据值        public String getData() {            return data;        }        // 更改数据值        public void setData(String data) {            this.data = data;        }    }    // ---------------------内部类----------------------------    public static void main(String[] args) {        LinkedListDemo l = new LinkedListDemo();        l.add("0");        l.add("1");        l.add("2");        l.add(0, "22");        l.add(4, "33");        System.out.println(l.indexOf("22"));        System.out.println(l.indexOf("33"));        System.out.println(l);    }}

Set

• 元素不重复
• 无序

HashSet

• 添加元素，不保证元素的顺序；底层依据元素的hashCode来存储【桶【1,2,3,4,5....哈希码的开头】】
• 相同元素：直接舍弃

验证：a验证思路：利用String的常量池和构造函数（new String(""))的地址的不同的特性dd("a");dd(new String("a"));for(String s:set){    if("a".equals(s)){        System.out.println("直接舍弃");    }else{        System.out.println("覆盖");    }}

• 默认初始容量16，加载因子0.75f--警戒线，扩容（第13位），每次扩容一倍16,32,64...
• 默认和加载因子都可以认为初始化
• equals--只要元素一致就为true，不关心元素的存储顺序
• 线程不安全的集合

Queue队列

• 先进先出
• 先放进去的元素：对头元素
• 最后放入的元素：队尾元素
• 方法

1. add--offer2. element（获取对头元素但不移除，获取失败报错NoSuchElementException）--peek（获取对头元素但不移除，获取失败返回null）3. poll--remove

 抛出异常返回特殊值插入add(e)offer()e移除removepoll检查elementpeek

线性集合--有序、线性的。List，Queue

Collections

• Collections的工具类
• 方法
• Comparator比较器（Collectios.sort(list,new Comparator（compare(){}）)）;

1. 反转列表reverse2. Collectios.sort(list,new Comparator（compare(){}）)    返回值为正数：s1>s2 交换    返回值为负数：s1<s2 不交换    如果没有指定规则，底层自动调用compareTo方法进行排序，元素对应的类必须实现Comparable接口，重写compareTo方法

疯狂值

• 集合实现

import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Scanner;public class CrazyExer1 {    public static void main(String[] args) {        Scanner s = new Scanner(System.in);        // 获取输入的数字个数        int number = s.nextInt();        List<Integer> list = new ArrayList<Integer>();        for (int i = 0; i < number; i++) {            list.add(s.nextInt());        }        s.close();        // 需要对集合进行排序        Collections.sort(list);        int sum1 = sort(list);        Collections.reverse(list);        int sum2 = sort(list);        System.out.println(sum1 > sum2 ? sum1 : sum2 );        // 5 10 15 20 50 70 80    }    public static int sort(List<Integer> list) {        // 存储排序之后的结果        List<Integer> result = new ArrayList<Integer>();        // 先放入集合的最后一位        result.add(list.get(list.size() - 1));        // 标记存放的情况        // 0->前小        // 1->后小        // 2->前大        // 3->后大        int i = 0;        for (int start = 0, end = list.size() - 2; start <= end;) {            if (i == 0) {                result.add(0, list.get(start));                start++;            } else if (i == 1) {                result.add(list.get(start));                start++;            } else if (i == 2) {                result.add(0, list.get(end));                end--;            } else {                result.add(list.get(end));                end--;                i = -1;            }            i++;        }        // 记录和        int sum = 0;        for (int j = 0; j < result.size() - 1; j++) {            sum += Math.abs(result.get(j) - result.get(j + 1));        }        return sum;    }}

• 数组实现

import java.util.Arrays;import java.util.Scanner;public class CrazyExer2 {    public static void main(String[] args) {        Scanner s = new Scanner(System.in);        int number = s.nextInt();        int[] arr = new int[number];        for (int i = 0; i < number; i++) {            arr[i] = s.nextInt();        }        s.close();        // 数组排序        Arrays.sort(arr);        int sum1 = sort(arr);        for (int start = 0, end = arr.length - 1; start < end; start++, end--) {            int temp = arr[start];            arr[start] = arr[end];            arr[end] = temp;        }        int sum2 = sort(arr);        System.out.println(sum1 > sum2 ? sum1 : sum2);    }    private static int sort(int[] arr) {        int[] result = new int[arr.length];        int mid = arr.length / 2;        result[mid] = arr[arr.length - 1];        int i = 0;        int offset = 1;        for (int start = 0, end = arr.length - 2; start <= end;) {            if (i == 0) {                result[mid - offset] = arr[start];                start++;            } else if (i == 1) {                result[mid + offset] = arr[start];                start++;                offset++;            } else if (i == 2) {                result[mid - offset] = arr[end];                end--;            } else {                result[mid + offset] = arr[end];                end--;                offset++;                i = -1;            }            i++;        }        int sum = 0;        for (int j = 0; j < result.length - 1; j++) {            sum += Math.abs(result[j] - result[j + 1]);        }        return sum;    }}