package cn.bjsxt;

//基于双向链表实现元素存取的容器
public class MyDoubleLinkList<E> implements Myist<E> {


    //记录头结点
    private Node head;
    //记录尾节点
    private Node tail;
    //记录元素个数
    private int size;

    //添加尾节点
    private void lastLinjk(E ele){
        //获取尾节点
        Node t = this.tail;
        //创建节点对象
      Node<E> node = new Node<>(ele,t,null) ;
      //将新节点定义为尾节点
        this.tail = node;
        if(t == null){
            this.head = node;
        }else {
            t.next = node;
        }
        this.size++;
    }
    //定一双向链表的节点对象
    class Node<E>{
        E item;//记录元素
        Node<E> prve;//记录前一个节点对象
        Node<E> next;//记录后一个节点对象
        Node(E item,Node<E> prve,Node<E> next){
            this.item = item;
            this.prve = prve;
            this.next = next;
        }
    }
    //添加元素的方法
    @Override
    public void add(E e) {
        this.lastLinjk(e);
    }
//获取元素的方法
    @Override
    public E get(int index) {
        //对index进行校验
        this.checkIndex(index);
        //根据索引获取节点对象
        Node<E> node = this.getNode(index);
        return node.item;
    }
//获取元素的个数
    @Override
    public int size() {
        return this.size;
    }
//删除元素
    @Override
    public E remove(int index) {
        //对index进行合法校验
        checkIndex(index);
        //根据指定位置获取节点对象
        Node<E> node = this.getNode(index);
        //获取节点对象中的元素
        E e = node.item;
        //判断当前节点是否为头节点
        if(node.prve == null){
            this.head =node.next;
        }else {
            //完成当前节点的直接前驱节点与当前节点的直接后继节点的挂接
            node.prve.next = node.next;
        }
        //判断当前节点是否为子节点
        if(node.next ==null){
            this.tail = node.prve;
        }else {
            //完成当前节点的直接后继节点与当前节点的直接前驱节点的链接
            node.next.prve = node.prve;
        }
        //当前节点断掉与他直接前驱节点的链接
        node.prve = null;
        //当前节点断掉与他直接后继节点的链接
        node.next = null;
        node.item = null;
        //记录元素个数
        this.size--;
        return e;
    }
    //校验index的特性
    private void checkIndex(int index){
        if(!(index >= 0 && index < this.size)){
            throw new IndexOutOfBoundsException();
        }
    }

    //根据索引获得指定对象
    private Node getNode(int index){
        if(index <(this.size>>1)){
            Node node = this.head;
            for (int i=0;i<index;i++){
                node = node.next;
            }
            return node;
        }else{
            Node node = this.tail;
            for (int i = this.size-1; i > index ; i--) {
                node = node.prve;
            }
            return node;
        }
        //在双向链表的头添加元素

    }
    public void addFirst(E e){
        lastLinjk(e);
    }
    //在链表头添加元素
    private void linkFirst(E e){
        //获取头节点对象
        Node head = this.head;

        Node node = new Node(e,null,head);
        //将新节点定义为头结点
        this.head = node;
        //判断当前节点中是否有头结点，如果没有，那么该节点是头结点也是尾节点
        if(head == null){
            this.tail = node;
        }else {
            head.prve = node;
        }
        //记录元素个数
        this.size++;
    }
    //在尾节点添加元素
    public void addLastLink(E e){
        this.lastLinjk(e);
    }
    public static void main(String[] args) {
        Myist<String> myist = new MyDoubleLinkList<>();
        myist.add("a");
        myist.add("b");
        myist.add("v");
        myist.add("d");
        myist.remove(2);
        for (int i = 0; i < myist.size(); i++) {
            System.out.println(myist.get(i));
        }
        System.out.println(myist.size());

        System.out.println("==============================");
        MyDoubleLinkList<String> list = new MyDoubleLinkList<>();
        list.add("a");
        list.addFirst("A");
        list.addLastLink("b");
        for (int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}
添加头结点元素添加失败？

只有一个端口怎样进行对服务器的输入啊。。。。。

public class IteratorRemoveTest {
    public static void main(String[] args) {
        //迭代器删除
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        boolean flag = false;
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String value = iterator.next();
            if ("c".equals(value)) {
                flag = true;
            }
        }
        if(flag){
            iterator.remove();
        }
        for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
    }

老师我这样删除c怎么没有删除掉？

public static void main(String[] args) {
    Map<String,String> map = new HashMap<>();
    //向map集合添加元素
    String str = map.put("a","N");
    String str1 = map.put("a","B");
    System.out.println(str1);//N
    //获取map集合的value值
     System.out.println(map.get("a"));//B
}

老师为什么上面这个输出语句输出的是N，下面这个通过get方法获取的value值是B，下面的str1不是吧之前的str值覆盖了吗

List是可以被序列化的吗？为什么源码里面找不到serilizable接口

关于视频中以下代码的疑问：

try {
    //创建Socket对象，两个参数：1、服务端的IP地址；2、服务端所监听的端口
   socket=new Socket("192.168.0.103",8888);
   pw=new PrintWriter(socket.getOutputStream());
   pw.println("服务端 您好！");
   pw.flush();
} catch (IOException e) {
    e.printStackTrace();
}

问题1：里面的pw.println("服务端 您好！")，这句代码是仅仅只有打印功能，还是兼具打印和输出功能呢？

问题2：PrintWriter不是具有自动行刷新缓冲字符的功能吗？为什么还要调用flush（）方法呢？

以上问题，烦请老师给予讲解，谢谢！

这里temp是int类型，为什么不用强转成char类型？

老师，为什么我感觉这里应该使用If else 否则无论怎样都会size--，求解答

com.bjsxtjava.io.BufferedReaderjava.io.IOExceptionjava.io.InputStreamReaderjava.io.PrintWriterjava.net.InetSocketAddressjava.net.ServerSocketjava.net.Socketjava.util.ScannerSend1 Thread{
    Socket Scanner (Socket socketScanner scanner){
        .= socket.= scanner}
    () {
        .sendMsg()}
    (){
PrintWriter pw = {
            pw = PrintWriter(..getOutputStream())() {
                String msg = .nextLine()pw.println(msg)pw.flush()}
        }(Exception e){
            e.printStackTrace()}{
            (!= ) {
                .close()}
            (pw != ) {
                pw.close()}
            (.!= ) {
                {
                    ..close()} (IOException e) {
                    e.printStackTrace()}
            }
        }
    }
}
Receive1 Thread{
    Socket (Socket socket){
        .= socket}
    () {
        .receiveMsg()}
    (){
        BufferedReader br = {
            br = BufferedReader(InputStreamReader(..getInputStream()))() {
                String msg = br.readLine()System..println(+msg)}
        }(Exception e){
            e.printStackTrace()}{
            (br != ) {
                {
                    br.close()} (IOException e) {
                    e.printStackTrace()}
            }
            (.!= ) {
                {
                    ..close()} (IOException e) {
                    e.printStackTrace()}
            }
        }
    }
}
GoodTCP {
    (String[] args) {
        Scanner scanner = ServerSocket serverSocket = Socket socket = {
            scanner = Scanner(System.)System..println()String str = scanner.nextLine()String[] arr = str.split()(.equals(arr[])) {
                System..println(+arr[]+)serverSocket = ServerSocket(Integer.(arr[]))socket = serverSocket.accept()System..println()}{
                socket = Socket(arr[]Integer.(arr[]))System..println()}
            Send1(socketscanner).start()Receive1(socket).start()} (Exception e) {
            e.printStackTrace()}{
            (serverSocket != ) {
                {
                    serverSocket.close()} (IOException e) {
                    e.printStackTrace()}
            }
        }
    }
}

报错异常：

请输入：server,<port>或者：<ip>,<port>

127.0.0.1,8888

java.net.ConnectException: Connection refused: connect

at java.net.DualStackPlainSocketImpl.connect0(Native Method)

at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:75)

at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:476)

at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:218)

at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:200)

at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:162)

at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:394)

at java.net.Socket.connect(Socket.java:606)

at java.net.Socket.connect(Socket.java:555)

at java.net.Socket.<init>(Socket.java:451)

at java.net.Socket.<init>(Socket.java:228)

at com.bjsxt.GoodTCP.main(GoodTCP.java:129)

Process finished with exit code 0

这个案例中为什么最后要转为字符流，是因为传输的是字符吗

老师，请问在电话本的那个项目中，是不是要在Operate中implements Serializable接口，但是在序列化到文件时要如何在oos.writeObject()中添加对象

为什么传入char型数组打印的不是数组的内容，而是数组的地址值？

老师，视频中的ip地址是这个

可是我的代码给我的ip地址是这个

为什么两个同样域名的ip地址不一样啊

package com.bjsxt;

/**
 * 基于单向链表实现元素存取的容器
 * @param <E>
 */
public class MySinglyLinkedList<E> implements MyList<E> {
    /**
     * 定义单向链表中的节点对象
     */
    class Node<E>{
        private E item;//存储元素
        private Node next;//存储下一个节点对象的地址
        Node(E item,Node next){
            //传递过来的参数传递给成员变量
            this.item = item;
            this.next = next;
        }
    }
    private Node head;//存放链表中的头节点。
    private int size;//记录元素个数
    @Override
    /**
     * 向链表中添加元素
     */
    public void add(E element) {
        //创建节点
        Node<E> node = new Node<>(element,null);
        //找到未节点
        Node tail = getTail();
        //节点的挂接
        if (tail == null){
            this.head = node;
        }else{
            tail.next=node;
        }
        //记录元素个数
        this.size++;

    }

    /**
     *找到尾节点
     */
    private Node getTail(){
        //头节点是否存在
        if (this.head == null){
            return null;
        }
        //查找尾节点
        Node node = this.head;
        while (true){
            if (node == null){
                break;
            }
            node  = node.next;//移动指针，指向下一个节点
        }
        return node;
    }

    @Override
    /**
     * 根据元素的位置获取元素
     */
    public E get(int index) {
        //校检Index的合法性
        this.checkIndex(index);
        //根据位置获取指定的节点
        Node<E> node = this.getNode(index);
        //将该节点中的元素返回
        return node.item;
    }

    /**
     * 对Index进行校验
     * @return
     */
    private void checkIndex(int index){
        if (!(index >=0 && index < this.size)){
            throw new IndexOutOfBoundsException("Index:"+index+"Size"+this.size);

        }
    }

    /**
     *根据位置获取指定的节点
     * @return
     */
    private Node getNode(int index){
        Node<E> node = this.head;
        for(int i=0;i<index;i++){
            node = node.next;
        }
        return node;
    }

    @Override
    /**
     * 获取元素个数
     */
    public int size() {

        return this.size;
    }

    @Override
    /**
     * 根据元素的位置删除元素
     * @param index
     * @return
     */

    public E remove(int index) {
        //校验Index的合法性
        this.checkIndex(index);
        //根据位置找到该节点对象
        Node<E> node = this.getNode(index);
        //获取该节点对象中的元素
        E item = node.item;
        //将该节点对象从单向表中移除
            //判断当前删除的节点是否为头节点
        if(this.head == node ){
            this.head = node.next;
        }else{
            Node<E> temp = this.head;
            for (int i = 0;i<index-1;i++){
                temp = temp.next;
            }
            temp.next = node.next;
        }
        node.next = null;
        //记录元素个数、
        this.size--;
        //将该元素返回
        return item;
    }

    public static void main(String[] args) {
        MySinglyLinkedList<String> mySinglyLinkedList = new MySinglyLinkedList<>();
        mySinglyLinkedList.add("a");
        mySinglyLinkedList.add("b");
        mySinglyLinkedList.add("c");
        mySinglyLinkedList.add("d");
        System.out.println("size:"+mySinglyLinkedList.size());
        System.out.println("删除："+mySinglyLinkedList.remove(0));
        for (int i =0;i<mySinglyLinkedList.size();i++){
            System.out.println(mySinglyLinkedList.get(i));

        }
    }
}

package com.bjsxt;

/**
 * 基于链表结构存取元素的方法 API 定义
 * @param <E>
 */
public interface MyList<E> {
    void add(E element);
    E get(int index);
    int size();
    E remove(int index);
}

运行效果图：

老师，1：我明明删除的是0索引，对应的应该是“a”才对怎么给我返回了个“d”啊，

2：我遍历的时候怎么给我报异常啊，明明是对着老师的代码敲的啊