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

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：我遍历的时候怎么给我报异常啊，明明是对着老师的代码敲的啊

1.座机号分为区号和后面七位或者八位，后面的第一位不能是0；

老师IDEA能不能想向eclipse这样打开多个项目啊，有时候想找一个类要切换项目感觉好麻烦 

我这是什么情况 怎么还报错了。。。。。commons没导入成功？

String，StringBuffer .append() 内存消耗，时间消耗测试：

问题：把 str8 = str8 + 2; 改成 str8 = str8 + i;之后，String消耗的时间变长，为什么String消耗的内存反而减少了，而且StringBuffer消耗的内存也变多了？

//获取迭代器对象
		Iterator<String> iterable = list.iterator();
		while(iterable.hasNext()){
			//String value = iterable.next();
			//System.out.println(value);
			System.out.println(iterable.next());
			
		}

老师这里直接在输出语句里面使用 next()方法不就可以了吗？视频中重新赋值了下，这样做有什么优势吗