老师，我这个也是报空指针异常，是21行那里，我的str初始值是null啊，找不到原因，请老师帮忙解答一下，谢谢

package com.bjsxt.test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server2 {
    public static void main(String[] args) {
        //(1)创建ServerSocket对象
        ServerSocket server = null;
        //(2)监听是否有客户端请求
        Socket client = null;
        BufferedReader br = null;
        try {
            server = new ServerSocket(12000);
            //(2)调用获取Socket对象
            client = server.accept();
            //(3)获取来自浏览器的信息
            br = new BufferedReader(new InputStreamReader(client.getInputStream(),"utf-8"));
            String str = null;
            while((str=br.readLine()).length()>0){  //将读到的信息赋给str，如果信息长度大于0的话，打印输出
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //(5)关闭
            IOClose.closeAll(br, client, server);
        }
    }
}

老师好！

请问为什么我把它变成批处理文件后在黑窗口打开会闪退

视频中的重写equals方法是这样的

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Users users = (Users) o;
    return userage ==   users.userage && Objects.equals(username, users.username);
}

视频配套的文档是下面这样的

 @Override
14  public boolean equals(Object o) {
15    if (this == o) return true;
16    if (o == null || getClass() != o.getClass()) return false;
17
18    Users users = (Users) o;
19
20    if (userage != users.userage) return false;
21    return username != null ? username.equals(users.username) : users.username == null;
22   }

最后两行是一样的吗

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));
        }
    }
}
添加头结点元素添加失败？

那我都可以用Edit Configurations下的 Proram arguments，还为什么要if语句中那么多的代码

关于buffer的算法问题，

课程中提到，buffer本质上就是上节课说的定义了byte，

那么是buffer是在内部，根据文件的大小，自动控制byte字节的大小吗？同时，也会根据大小，自动选择上一节课的方式1或者方式2？

一、

/**
 * 对象流将list存储(序列化)到文件中
 */
public void savePersonList() {
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/a.txt")));
        for (int i = 0; i < this.list.size(); i++) {
            oos.writeObject(this.list.get(i));
        }
        oos.flush();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (oos != null) {
                oos.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、

/**
 * 获取文件的对象信息（对象的反序列化）
 */
public void getPersonList() {
    //声明流
    FileInputStream fis = null;
    ObjectInputStream ois = null;
    try{
        //实例化流对象
        fis = new FileInputStream("d:/a.txt");
        ois = new ObjectInputStream(new BufferedInputStream(fis));
        try{
            while (fis.available()==0){
                Person person = (Person) ois.readObject();
                list.add(person);
            }
        }catch (Exception e){
            System.out.println("获取上次记录成功！");
        }
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        try{
            if (fis!=null){
                fis.close();
            }
            if (ois!=null){
                ois.close();
            }
        }catch (Exception E){
            E.printStackTrace();
        }
    }
}

三、问题（程序可以运行成功。实现对象存入文件，并启动程序时读取文件中的对象到list）

遇到的问题：1、代码块二中，while循环里判断条件是（fis.available()==0），我是在网上找的这个判断读取完成的条件。如果条件换成true也可以运行出来，老师可以讲讲区别吗，available方法是什么作用？

2、代码块二中、这里流的关闭顺序不清楚（主要是开启的顺序不知道）

3、老师看看代码有什么需要改进的地方吗？

老师，我的代码按照视频中的敲的，但是出了问题，反复检查了几遍无结果还请老师帮忙看一下！

book.xsd中的代码：

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" >
	<xs:element name="books">
		<xs:complexType>   <!-- 复杂元素 -->
			<xs:sequence>
				<xs:element name="book" maxOccurs="unbounded"><!-- 第一个元素以及可以出现多个所以为unbounded -->
					<xs:complexType>
						<xs:sequence><!-- 子标签出现是有一定顺序的 -->
							<xs:element name="name" type="xs:string"></xs:element>
							<xs:element name="author" type="xs:string" ></xs:element>
							<xs:element name="price" type="xs:double"></xs:element>
						</xs:sequence>
						<xs:attribute name="id" type="xs:positiveInteger" use="required"></xs:attribute>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
		</xs:complexType>
	</xs:element>
</xs:schema>

book.xml中的代码:

<?xml version="1.0" encoding="UTF-8"?>
<books xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="{book.xsd}">
	<book id="1001">
		<name>java开发实战</name>
		<author>江小欧</author>
		<price>99.9</price>
		
	</book>
	<book id="1002">
		<name>mysql从删库到跑路</name>
		<author>江小白</author>
		<price>89.7</price>
	</book>
</books>

Test类：

package cn.sxt.schema;

import java.io.File;
import java.io.IOException;

import javax.xml.bind.JAXBException;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

import org.xml.sax.SAXException;

public class Test92 {
	public static void main(String[] args) throws SAXException {
		//1.创建SchemaFactory工厂
		SchemaFactory sch = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
		//2.建立验证文件对象
		File schemaFile = new File("book.xsd");
		//3.利用SchemaFactory工厂对象，接收验证的文件对象，生成Schema对象
		Schema schema = sch.newSchema(schemaFile);
		//4.生产对此schema的验证器
		Validator validator = schema.newValidator();
		//5.要验证的数据(准备数据源)
		Source source = new StreamSource();
		//6.开始验证
		try {
			validator.validate(source);
			System.out.println("成功");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("失败");
		}
	}
}

运行错误图：

老师showAll方法递归里面视频写的是 showAll(file2,num+1)我写成showAll(file2,num++)为什么效果图完全不一样

public class SeriesFile {
	public static void showAll(File file,int num) {//遍历所有文件,file是用于下面判断是否为文件夹，num是判断层次
		//使用循环打印-
		for(int i=0;i<num;i++) {
			System.out.print("-");
		}
		//打印文件名称
		System.out.println(file.getName());
		//判断是否为文件
		if(file.isDirectory()) {
			//是文件，遍历文件
			File[] files=file.listFiles();
			for (File file2 : files) {
				//递归使用方法
				//num自增一次
				showAll(file2, num+1);
			}
		}
	}
	
	public static void main(String[] args) {
		File file=new File("D:\\尚学堂资料");
		showAll(file, 0);
	}
}

正确显示

showAll(file2,num+1)结果

show(file2,num++)结果

StringBuilder sb=new StringBuilder("abc");

老师这里的abc是赋给了谁呢，是sb还是类对象啊

我写了个乞丐版的LinkedList，主要是实现add，remove，get方法，但是remove方法一直报异常，麻烦老师看一下问题出在了哪里，以下是源码

LinkedList类

package TestLinkedList;
public class LinkedList {
 private Node first=null;
 private Node last=null;
 private int size;
 //索引返回值
 Object node(int index) {
  Node x=first;
  for(int i=0;i<index;i++) {
      x=first;
   x=x.next;
  }return x.object;
 }
 //tostring方法 
 public String toString() {
    String result="";
    //如果链表中没有根节点，直接返回空
    if(first!=null){
        Node temp = first;
        result=temp.object.toString();
        //如果已经遍历到最后一个节点，结束
        while(temp.next!=null){
         result+=","+temp.next.object.toString();
         temp=temp.next;
        }
    }
    return "LinkedList [" +result + "]";
   }
 //add方法
 public void add(Object object) {
  Node l=last;
  Node newnode=new Node(l,object,null);
  last=newnode;
  if(l==null) {
   first=newnode;
  }else {
   l.next=newnode;
  }
  size++;
 };
 //remove方法
 public void remove(Object object) {
  Node l=last;
  Node f=first;
  
  for(int i=0;i<size;i++)
   {
   if(f.equals(object)) {
   break;}
   f=f.next;
   
  }
  if(f.prv==null&&f.next!=null) {
   f.next=first;
  }else if(f.prv!=null&&f.next==null) {
   f.prv=last;
   
  }else if(f.prv!=null&&f.next!=null) {
   f.prv.next=f.next;
   f.next.prv=f.prv;
  }
  f.object=null;
  size--;
 }
 //get方法
public Object get(int index) {
 Object d=node(index);
 return d;
  
 }
 
}

Node类

package TestLinkedList;
public class Node {
 Object object;
 Node prv;
 Node next;
public  Node(Node prv,Object object,Node next) {
 this.prv=prv;
 this.object=object;
 this.next=next;
 
}
public Node() {
 
}
}

Test测试

package TestLinkedList;
public class Test {
 public static void main(String[] args) {
 LinkedList link=new LinkedList();
 //测试add
 link.add("hi");
 link.add("word");
 //测试tostring
 System.out.println(link);
 //测试get
 System.out.println(link.get(1));
 //测试remove
 link.remove("word");
 System.out.println(link);
 }
}

运行效果

老师，所报的错误是什么原因啊，检查不出来

对应代码如下：

老师为什么返回 this.age-p.getAge()就是按照升序排序了？ 这句代码有什么含义呀

通常异常处理的方式，就是把遇到问题的语句停止，继续执行下面的语句