老师，如果是一个二维Object数组，怎么把他转为对象数组或对象集合呢。

package com.bjsxt.test.container;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Arrays;
import java.util.List;

public class TestArrayList {

    @Test
    public void test() {
        Object[][] objects = new Object[2][];
        Object [] object1 = new Object[3];
        object1[0] = 001;
        object1[1] = "张三";
        object1[2] =15;

        Object [] object2 = new Object[3];
        object2[0] = 002;
        object2[1] = "张一";
        object2[2] =18;
        objects[0] = object1;
        objects[1] = object2;

        List<Object[]> list = Arrays.asList(objects);  
    
        People[] peoples = list.toArray(new People[list.size()]);  //报错了java.lang.ArrayStoreException
    }
}

class People{
    public Integer id;
    public String name;
    public Integer age;
}

这种情况只能循环List<Object[]> list 然后把每一个Object[ ]的值取出来赋给People 存起来吗

这个代码开始就写好了，是中间少了一节课吗

public class CalendarClass {
    public static void main(String[] args) {
GregorianCalendar calendar1=new GregorianCalendar(2999,10,9,22,10,50);
calendar1.add(Calendar.MONTH,-7);//月份减七
System.out.println("calendar1月份(原来10)减七："+calendar1.MONTH);
calendar1.add(Calendar.MONTH,7);//月份加七
System.out.println("calendar1月份(被减七后加七)加七："+calendar1.MONTH);
    }
}

月份减七加七后不应回复为原来的嘛？而且 10-7=3为什么返回值是二啊？（试了好几遍一直是这样）

DateFormatClass {
    (String[] args) ParseException {
        SimpleDateFormat s1=SimpleDateFormat()SimpleDateFormat s2=SimpleDateFormat()String daytime =s1.format(Date())System..println(daytime)System..println(s2.format(Date()))System..println(SimpleDateFormat().format(Date()))SimpleDateFormat df=SimpleDateFormat()Date dd=df.parse()System..println(dd.getTime())}

}

为什么我这里最后运行报错呢？

相关代码：Request类

package com.bjsxt.server;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Request {//请求
	private InputStream is;//输入流
	private String requestInfo;//请求字符串，请求方式，请求路径，参数，协议，协议版本，请求正文
	private String method;//请求方式
	private String url;//请求的url
	//输入框name为key，值为value
	/**
	 * key:username value:bjsxt
	 * key:pwd		value:123
	 * key:hobby 	value:    read,ball
	 */
	private Map<String,List<String>> parametermapValues;//参数 
	private static final String CRLF="\r\n";//换行
	private static final String BLANK=" ";//空格
	//构造方法，初始化属性
	public Request() {
		parametermapValues=new HashMap<String,List<String>>();
		method="";
		url="";
		requestInfo="";
	}
	public Request(InputStream is) {
		this();
		this.is=is;
		try {
			byte[]buf=new byte[20480];
			int len=this.is.read(buf);
			requestInfo=new String(buf,0,len);
		} catch (IOException e) {
			return;
		}	
		this.parseRequestInfo();
	}//分解请求信息的方法
	/**请求方式
	 * 请求路径
	 * 请求参数
	 * 
	 */
	private void parseRequestInfo() {
		String paraString="";//用于存储请求参数
		//获取请求参数的第一行
		String firstLine = requestInfo.substring(0, requestInfo.indexOf(CRLF)).trim();
		//分解出请求方式
		int index = firstLine.indexOf("/");
		this.method=firstLine.substring(0, index).trim();
		//分解url，可能包含参数（get），也可能不包含参数（post）
		String urlString = firstLine.substring(index,firstLine.indexOf("HTTP/") ).trim();
		if ("get".equalsIgnoreCase(this.method)) {
			if (urlString.contains("?")) {
				String[] urlArray=urlString.split("\\?");
				this.url=urlArray[0];
				paraString=urlArray[1];
				
			}else {
				this.url=urlString;
			}
		}else {//不包含请求参数
			this.url=urlString;
			paraString=requestInfo.substring(requestInfo.lastIndexOf(CRLF)).trim();						
		}
		if (paraString.equals("")) {
			return;
		}
		//请求参数
		System.out.println(paraString);
	}//用于测试
	public void show() {
		System.out.println(this.url);
		System.out.println(this.method);
	}
}

Server类

package com.bjsxt.server;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {//服务器，用于启动和停止服务
	private ServerSocket server;
	public static void main(String[] args) {
		Server server=new Server();
		server.start();
	}
	public void start() {
		this.start(8888);
	}
	public void start(int port) {
		try {
			server=new ServerSocket(port);
			this.receive();//请求接收信息的方法
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	private void receive() {
		//监听
		try {
			Socket client=server.accept();
			//获取用户请求
			/*InputStream is=client.getInputStream();
			byte[] buf=new byte[20480];
			int len=is.read(buf);			
			System.out.println(new String(buf,0,len));*/
			//封装请求信息
			Request req=new Request(client.getInputStream());
			req.show();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

老师，为什么post没有显示参数啊

get方式

public <T> void setArgs(T...args){
    for(T arg: args){
        System.out.println(arg);
    }
}

//情况1：
Integer[] i = new Integer[]{1,2,3,4,5,6};
generic.setArgs(2,i);
//情况2：
Integer[] i = new Integer[]{1,2,3,4,5,6};
generic.setArgs(i);

情况1效果：

情况2效果：

老师，为什么情况1打出来的是内存地址，情况2是把数值打印出来

你好，老师这一章节的提取码显示不正确，能发一个正确的吗？

一、问题：判断一个字符串的对称性。

老师，为啥我输出的会是false，感觉逻辑没有问题，而且代码跟老师讲课一样，但为什么输出的不是true。

二、代码

package com.bjsxt;

import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        System.out.println("-------判断字符串的对称性---------");
        StackTest stackTest = new StackTest();
        stackTest.symmetry();
    }
    //判断字符串的对成型
    public void symmetry(){
        String str="...{.....[....(....)...]....}..(....)..[...]...";
        Stack<String> stack = new Stack<>();
        boolean flag = true;//假设是匹配的
        for (int i=0;i<str.length();i++){
            char c = str.charAt(i); //拆分字符，把字符拿出来
            if (c=='{'){
                stack.push("}");
            }
            if (c=='['){
                stack.push("]");
            }
            if (c=='('){
                stack.push(")");
            }
            if (c == '）'|| c == ']'|| c == '}'){
                //修正处理
                if (stack.empty()){
                    flag = false;
                    break;
                }
                String x = stack.pop();
                //修正处理
                if (x.charAt(0) != c){
                    flag = false;
                    break;
                }
            }
        }
        if (!stack.empty()){
            flag = false;
        }
        System.out.println(flag);
    }
}

三、运行效果图

数据结构中，链表结构里的节点和结点有啥区别

老师，我看源码有两个问题。1.Calendar有一个方法

public static Calendar getInstance()

这个方法返回了一个Calendar, 抽象类不是不能被实例化吗，我一个个方法点进去也没懂他是怎么创建的实例，然后这个方法也返回了一个Calendar

2.通过这个方法返回的Calendar也有GregorianCalendar类函数，他们有什么差别吗，真正做开发的时候用哪个? getInstance还是实例化GregorianCalendar

为什么long time=1000;放方法里面运行是这样啊

InetSocketAddress isa = new InetSocketAddress("localhost",9999); 
InetSocketAddress isa2 = new InetSocketAddress("127.0.0.1",9999); 
InetSocketAddress isa3 = new InetSocketAddress("192.168.1.2",9999);

isa返回结果：

isa2返回结果：

isa返回结果:

老师这三个不都是指本机嘛，为什么三次返回的主机名称不一样？只有输入IP地址的返回的我电脑的名称？

老师 想要JDK1.8资源 之前发的链接打不开 过期了

如上图：while循环里面是一直在创建线程吧，那为什么老师说每有一个客户端就创建一个线程

图2:

package chatGroup;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.List;

/**
 * 服务器路径线程
 */
public class MyChannel implements Runnable{
    private DataInputStream dis;
    private DataOutputStream dos;
    private boolean flag=true;

    public MyChannel(Socket socket) {
        try {
            dis=new DataInputStream(socket.getInputStream());
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dis);
        }
        try {
            dos=new DataOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dos);
        }
    }

    @Override
    public void run() {
        while (flag){
            //this.send(gain());
            sendOther();
        }
    }
    public String gain(){
        String str="";
        try {
            str=dis.readUTF();
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dis);
            MyServer.list.remove(this);
        }
        return str;
    }
    public void send(String str){
        if (str!=null&&str.length()!=0){
            try {
                dos.writeUTF(str);
                dos.flush();
            } catch (IOException e) {
                flag=false;
                CloseUtil.close(dos);
                MyServer.list.remove(this);
            }
        }
    }
    public void sendOther(){
        String str=this.gain();
        List<MyChannel> list=MyServer.list;
        for (MyChannel other:list){
            if (other==this){
                continue;
            }
            other.send(str);
        }
    }
}

图2中：Myserver.list.remove(this),将元素从容器中移除，这里的元素就是客户端，如果客户端发送的流出了异常，接收流没有出异常，就删除该客户端吗，就是说接收和发送只要一个有异常就移除这个客户端吗？