编码和解码\数据结构:链表, 栈\Collection(I): 集合List

一。编码和解码
byte[] getBytes(); -> 根据默认字符集来编码
new String(bs); -> 按照默认字符集解码
byte[] getBytes(“charset”) -> 按照指定字符集编码
new String(bs1, “gbk”); -> 按照指定字符集解码

public class Sbs {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //编码和解码的类型要一致
        //字符->字节 编码
        String m="你好";
        byte[] n=m.getBytes("gbk");
        System.out.println(Arrays.toString(n));
        //字节->字符  解码
        String h=new String(n,"gbk");
        System.out.println(h);

        //解决乱码
        String n1=new String(n,"ISO8859-1");//乱码出现 ÄãºÃ
        //按照ISO8859-1重新编码回去
        byte[] x=n1.getBytes("ISO8859-1");
        //按照正确的gbk解码
        String xx=new String(x,"gbk");
        System.out.println(xx);//你好
        //--------------------------------
        //解决乱码简化写法
        n1=new String(n1.getBytes("ISO8859-1"),"gbk");
        System.out.println(n1);
    }
}

二。数据结构: 存储数据的方式
数组, 链表, 栈, 队列, 二叉树
1.栈: 弹夹, push():压栈 pop():弹栈
Stack: 先进后出, 后进先出

public class Stack<T> {
    private Object[] data; // 定义一个用于存数据的仓库
    private int size; // 表示栈中的元素个数

    public Stack(int cap) { // cap: 表示栈的最大容量
        data = new Object[cap];
    }
    // 压栈
    public void push(T a) {
        data[size++] = a;
    }
    // 弹栈 -> 从栈顶开始
    public T pop() {
        T a = (T) data[size-1];
        size --;
        return a; // return data[--size]
    }
    // 获取元素个数
    public int size() {
        return size;
    }

    // 判断栈是否满
    public boolean isFull() {
        return size == data.length;
    }
    // 判断栈是否为空
    public boolean isEmpty() {
        return size == 0;
    }
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            sb.append(",");
        }
        if (size != 0) {
            // 去掉最后一个逗号
            sb.delete(sb.length() - 1, sb.length());
        }
        sb.append("]");
        return sb.toString();
    }
}

public class DemoStack {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack(8);
        while (!stack.isFull()) {
            stack.push(3);
        }
        System.out.println(stack);
        while (!stack.isEmpty()) {
            int a = stack.pop();

            System.out.println(a);
        }
        System.out.println(stack);
    }
}

2.链表
链表: 末尾添加元素, 插入元素, 获得指定位置的元素, 删除指定位置元素

// 单向链表
public class SingleLinked<T> {
    // 结点类型
    private class Node {
        private T data; // 用于存储数据
        private Node next; // 用于存下一个结点的地址
        public Node(T data) {
            this.data = data;
        }
    }
    // 最开始初始化链表时, head不存储数据, next是null
    private Node head = new Node(null);
    // 添加新的结点
    public void add(T a) {
        // 寻找next=null 的结点
        Node node = head;
        while (node.next != null) {
            node = node.next;
        }
        // 所以node.next == null时
        node.next = new Node(a);
    }
    // 得到index-1位置上的元素
    private Node getIndexPreNode(int index) {
        Node node = head;
        // 要找到index-1这个位置的Node
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }
    // 在index位置上插入元素
    public void insert(int index, T a) {
        Node node = getIndexPreNode(index);
        Node node3 = new Node(a);
        node3.next = node.next;
        node.next = node3;
    }
    // 获得index位置上的元素
    public T get(int index) {
        Node node = getIndexPreNode(index);
        return node.next.data;
    }

    // 删除index位置上的元素
    public void remove(int index) {
        Node node = getIndexPreNode(index);
        node.next = node.next.next;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node node = head;
        while (node.next != null) {
            node = node.next;
            sb.append(node.data);
            sb.append(", ");
        }
        sb.append("]");
        return sb.toString();
    }
}

public class DemoSingleLinked {
    public static void main(String[] args) {
        SingleLinked<Integer> linked = new SingleLinked();
        linked.add(3);
        linked.add(5);
        linked.add(2);

        linked.insert(1, 8);

        System.out.println(linked);

        System.out.println(linked.get(3));
        linked.remove(2);
        System.out.println(linked);
    }
}

3. 数组和链表的优劣势比较:
1.数组的物理空间连续, 碎片化空间使用不彻底
  链表物理空间不连续, 空间使用彻底
2.链表只能从head开始访问, 访问效率低
  数组可以随机访问任意元素, 访问效率高
3.链表插入/移除元素, 只需要操作1~2个元素, 效率高
  数组插入/移除元素, 涉及到大量元素的移动, 效率低

三。Collection(I): 集合

1. |- List(I) -> 顺序结构(数组和链表)
   |- ArrayList - 数组
   |- LinkedList - 双向链表
   |- Vector - 数组
   |- Queue(I) -> 队列结构(普通队列)
   |- Deque(I) 队列结构(双端队列, 栈)
   |- LinkedList
   |- Set(I) -> 散列结构(没有顺序)
   |- HashSet
   |- SortedSet(I)
   |- TreeSet - 二叉树
2. List的API: 可以使用index
   void add(int index, E element)
   void addAll(int index, Collection<? extends E> c)
   E get(int index)
   int indexOf(Object o)
   int lastIndexOf(Object o)
   E remove(int index)
   E set(int index, E element)

public class Listttt {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("李小璐");
        list.add("贾乃亮");
        list.add("王宝强");
        list.add("马蓉");
        System.out.println(list);
        list.get(2);
        System.out.println(list.get(2));
        list.remove("贾乃亮");
        System.out.println(list);
        List<String> list1=new ArrayList<String>();
        list1.add("王俊凯");
        list1.add("易烊千玺");
        list1.add("王源");
        list.addAll(list1);
        list.set(2,"马沙拉");
        System.out.println(list);
        System.out.println(list.containsAll(list1));

        Iterator<String>it=list.iterator();
        while(it.hasNext()){
            String s=it.next();
            it.remove();//用迭代器删除元素
            System.out.println(list);
        }
        System.out.println(list);
    }
}