Java 泛型、栈和链表

1. Java的编码方式

 JVM中，1个字符 = 2个字节 使用Unicode的编码方式

 不同的操作系统有不同的编码方式：

  Windows：GBK GB2312
   1char = 3byte

  Linux:UTF-8
   1char = 2byte

 API简介：

        byte[] getBytes(); -> 根据默认字符集来编码
        new String(bs); -> 按照默认字符集解码

        byte[] getBytes("charset") -> 按照指定字符集编码
        new String(bs1, "gbk"); -> 按照指定字符集解码

package CharSet;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Demo01StringCharset {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str = "你好!";

        //控制台打印
        //字符->字节(编码)
        byte[] a = str.getBytes();
        System.out.println(str);

        System.out.println(Arrays.toString(a));
        //[-28, -67, -96, -27, -91, -67, 33]    一个字符等于3个字节  UTF-8

        byte[] b = str.getBytes("GBK");
        System.out.println(Arrays.toString(b));
        //[-60, -29, -70, -61, 33]  一个字符等于2个字节  GBK     符号占一个字节？

        //解码
        String a1 = new String(a);
        System.out.println(a1);
        //UTF-8解码方式

        String b1 = new String(b,"GBK");    //按照GBK编码方式进行解码
        System.out.println(b1);
        //GBK解码方式
    }
}

package CharSet;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Demo02String {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //手动制造乱码
        String str = "乱码";
        byte[] a = str.getBytes();  //转化为字节
        System.out.println(Arrays.toString(a));

        //把字节转换成ISO8859-1的编码方式，出现乱码
        String a1 = new String(a, "ISO8859-1");
        //输出乱码
        System.out.println(a1);

        //先转换为字节，再转换成UTF-8的编码方法
        String s = new String(a1.getBytes("ISO8859-1"), "UTF-8");
        System.out.println(s);
    }
}

2. 泛型

 泛型：本质是参数化的类型，可以在类或方法中预知地使用未知的类型。

 Tips：一般在创建对象时，将未知的类型确定具体类型。 当没有指定泛型时，默认类型为Object类型。

 代码应用：

package generic;

public class Demo03Test {
    public static void main(String[] args) {
        Demo03<String> d3 =new Demo03<>();
        d3.setT("haha");
        String a = d3.getT();
        System.out.println(a);

        Demo03<Integer> d31 = new Demo03<>();
        d31.setT(123);
        System.out.println(d31.getT());
    }
}

public class Demo03<T> {
    private T t;

    public T getT() {
        return t;
    }

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

3. 栈

package dateStructure;

public class StackTest {
    public static void main(String[] args) {
        Stack<Integer> st = new Stack(8);

        while (!st.isFull()) {
            st.push(1);
        }
        System.out.println(st.toString());

        while (!st.isEmpty()) {
            st.pop();
        }
        System.out.println(st.toString());
    }
}

package dateStructure;

public class Stack<E> {
    private Object[] data;
    private int size;

    public Stack(int cap) {
        data = new Object[cap];
    }

    //压栈
    public void push(E a) {
        data[size++] = a;
    }

    //弹栈
    public E pop() {
        E a = (E) data[size - 1];
        size--;
        return a;
    }

    //判断栈是否满了
    public boolean isFull() {
        return size == data.length;
    }

    //判断栈是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(data[i]+",");
        }
        sb.append("]");
        return sb.toString();
    }
}

4. 链表

package dateStructure;

public class SingleLinked<E> {

    //节点类型
    private class Node<E> {
        private E data;//用于存储数据
        private Node next;//用于存储下个节点的位置

        Node(E data) {
            this.data = data;
        }
    }

    //初始化链表， head不存储数据，next是null
    private Node head = new Node(0);

    public void add(Object a) {
        Node node = head;
        while (node.next != null) {
            node = node.next;
        }
        node.next = new Node(a);
    }

    //获取Index-1位置上的元素
    public Node<E> getIndexPreNode(int index) {
        Node node = head;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    //插入
    public void insert(int index, E a) {
        Node node = getIndexPreNode(index);
        Node addNode = new Node(a);
        addNode.next = node.next;
        node.next = addNode;
    }

    //获取
    public void get(int index) {
        Node node = getIndexPreNode(index);
        System.out.println(node.next.data);
    }

    //删除
    public void remove(int index) {
        Node node = getIndexPreNode(index);
        node.next = node.next.next;
    }

    @Override
    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("]");
        return sb.toString();
    }
}

package dateStructure;

public class SingleLinkedDemo {
    public static void main(String[] args) {
        SingleLinked<Integer> linked = new SingleLinked();
        //添加
        linked.add(11);
        linked.add(13);
        linked.add(21);

        //插入
        linked.insert(1, 9);
        //获取
        linked.get(3);
        System.out.println(linked.toString());

        //删除
        linked.remove(0);
        System.out.println(linked.toString());
    }
}