API-day08
Chat Room (continued)
Realize that the server sends messages to the client
The server obtains the output stream through Socket, the client obtains the input stream, and realizes that the server sends messages to the client.
Here let the server directly reply the message sent by the client to the client for testing.
Server code:
package socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 聊天室服务端
*/
public class Server {
/**
* 运行在服务端的ServerSocket主要完成两个工作:
* 1:向服务端操作系统申请服务端口，客户端就是通过这个端口与ServerSocket建立链接
* 2:监听端口，一旦一个客户端建立链接，会立即返回一个Socket。通过这个Socket
* 就可以和该客户端交互了
*
* 我们可以把ServerSocket想象成某客服的"总机"。用户打电话到总机，总机分配一个
* 电话使得服务端与你沟通。
*/
private ServerSocket serverSocket;
/**
* 服务端构造方法，用来初始化
*/
public Server(){
try {
System.out.println("正在启动服务端...");
/*
实例化ServerSocket时要指定服务端口，该端口不能与操作系统其他
应用程序占用的端口相同，否则会抛出异常:
java.net.BindException:address already in use
端口是一个数字，取值范围:0-65535之间。
6000之前的的端口不要使用，密集绑定系统应用和流行应用程序。
*/
serverSocket = new ServerSocket(8088);
System.out.println("服务端启动完毕!");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 服务端开始工作的方法
*/
public void start(){
try {
while(true) {
System.out.println("等待客户端链接...");
/*
ServerSocket提供了接受客户端链接的方法:
Socket accept()
这个方法是一个阻塞方法，调用后方法"卡住"，此时开始等待客户端
的链接，直到一个客户端链接，此时该方法会立即返回一个Socket实例
通过这个Socket就可以与客户端进行交互了。
可以理解为此操作是接电话，电话没响时就一直等。
*/
Socket socket = serverSocket.accept();
System.out.println("一个客户端链接了！");
//启动一个线程与该客户端交互
ClientHandler clientHandler = new ClientHandler(socket);
Thread t = new Thread(clientHandler);
t.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Server server = new Server();
server.start();
}
/**
* 定义线程任务
* 目的是让一个线程完成与特定客户端的交互工作
*/
private class ClientHandler implements Runnable{
private Socket socket;
private String host;//记录客户端的IP地址信息
public ClientHandler(Socket socket){
this.socket = socket;
//通过socket获取远端计算机地址信息
host = socket.getInetAddress().getHostAddress();
}
public void run(){
try{
/*
Socket提供的方法:
InputStream getInputStream()
获取的字节输入流读取的是对方计算机发送过来的字节
*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, "UTF-8");
BufferedReader br = new BufferedReader(isr);
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
PrintWriter pw = new PrintWriter(bw,true);
String message = null;
while ((message = br.readLine()) != null) {
System.out.println(host + "说:" + message);
//将消息回复给客户端
pw.println(host + "说:" + message);
}
}catch(IOException e){
e.printStackTrace();
}
}
}
}
Client code:
package socket;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
/**
* 聊天室客户端
*/
public class Client {
/*
java.net.Socket 套接字
Socket封装了TCP协议的通讯细节，我们通过它可以与远端计算机建立链接，
并通过它获取两个流(一个输入，一个输出)，然后对两个流的数据读写完成
与远端计算机的数据交互工作。
我们可以把Socket想象成是一个电话，电话有一个听筒(输入流)，一个麦克
风(输出流)，通过它们就可以与对方交流了。
*/
private Socket socket;
/**
* 构造方法，用来初始化客户端
*/
public Client(){
try {
System.out.println("正在链接服务端...");
/*
实例化Socket时要传入两个参数
参数1:服务端的地址信息
可以是IP地址，如果链接本机可以写"localhost"
参数2:服务端开启的服务端口
我们通过IP找到网络上的服务端计算机，通过端口链接运行在该机器上
的服务端应用程序。
实例化的过程就是链接的过程，如果链接失败会抛出异常:
java.net.ConnectException: Connection refused: connect
*/
socket = new Socket("localhost",8088);
System.out.println("与服务端建立链接!");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 客户端开始工作的方法
*/
public void start(){
try {
/*
Socket提供了一个方法:
OutputStream getOutputStream()
该方法获取的字节输出流写出的字节会通过网络发送给对方计算机。
*/
//低级流，将字节通过网络发送给对方
OutputStream out = socket.getOutputStream();
//高级流，负责衔接字节流与字符流，并将写出的字符按指定字符集转字节
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
//高级流，负责块写文本数据加速
BufferedWriter bw = new BufferedWriter(osw);
//高级流，负责按行写出字符串，自动行刷新
PrintWriter pw = new PrintWriter(bw,true);
//通过socket获取输入流读取服务端发送过来的消息
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in,"UTF-8");
BufferedReader br = new BufferedReader(isr);
Scanner scanner = new Scanner(System.in);
while(true) {
String line = scanner.nextLine();
if("exit".equalsIgnoreCase(line)){
break;
}
pw.println(line);
line = br.readLine();
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
/*
通讯完毕后调用socket的close方法。
该方法会给对方发送断开信号。
*/
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Client client = new Client();
client.start();
}
}
The server forwards the message to all clients
When a client sends a message, how does the server forward it to all clients after receiving it.
Question: For example, how does the red thread get the output stream in the orange thread 2 after receiving the client message? If it is not obtained, the message cannot be forwarded to the orange client (further extension is that it cannot be forwarded to all other clients)
Solution: The internal class can access the members of the external class, so define an array allOut on the Server class that can be accessed by all internal class ClientHandler instances. Therefore, the data that these ClientHandler instances want to visit each other are stored in this array to achieve shared data Purpose. To this end, it is only necessary to store all the output streams in the ClientHandler in the array allOut to achieve the purpose of mutual access to the output streams and forwarding messages.
Server code:
package socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
/**
* 聊天室服务端
*/
public class Server {
/**
* 运行在服务端的ServerSocket主要完成两个工作:
* 1:向服务端操作系统申请服务端口，客户端就是通过这个端口与ServerSocket建立链接
* 2:监听端口，一旦一个客户端建立链接，会立即返回一个Socket。通过这个Socket
* 就可以和该客户端交互了
*
* 我们可以把ServerSocket想象成某客服的"总机"。用户打电话到总机，总机分配一个
* 电话使得服务端与你沟通。
*/
private ServerSocket serverSocket;
/*
存放所有客户端输出流，用于广播消息
*/
private PrintWriter[] allOut = {
};
/**
* 服务端构造方法，用来初始化
*/
public Server(){
try {
System.out.println("正在启动服务端...");
/*
实例化ServerSocket时要指定服务端口，该端口不能与操作系统其他
应用程序占用的端口相同，否则会抛出异常:
java.net.BindException:address already in use
端口是一个数字，取值范围:0-65535之间。
6000之前的的端口不要使用，密集绑定系统应用和流行应用程序。
*/
serverSocket = new ServerSocket(8088);
System.out.println("服务端启动完毕!");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 服务端开始工作的方法
*/
public void start(){
try {
while(true) {
System.out.println("等待客户端链接...");
/*
ServerSocket提供了接受客户端链接的方法:
Socket accept()
这个方法是一个阻塞方法，调用后方法"卡住"，此时开始等待客户端
的链接，直到一个客户端链接，此时该方法会立即返回一个Socket实例
通过这个Socket就可以与客户端进行交互了。
可以理解为此操作是接电话，电话没响时就一直等。
*/
Socket socket = serverSocket.accept();
System.out.println("一个客户端链接了！");
//启动一个线程与该客户端交互
ClientHandler clientHandler = new ClientHandler(socket);
Thread t = new Thread(clientHandler);
t.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Server server = new Server();
server.start();
}
/**
* 定义线程任务
* 目的是让一个线程完成与特定客户端的交互工作
*/
private class ClientHandler implements Runnable{
private Socket socket;
private String host;//记录客户端的IP地址信息
public ClientHandler(Socket socket){
this.socket = socket;
//通过socket获取远端计算机地址信息
host = socket.getInetAddress().getHostAddress();
}
public void run(){
try{
/*
Socket提供的方法:
InputStream getInputStream()
获取的字节输入流读取的是对方计算机发送过来的字节
*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, "UTF-8");
BufferedReader br = new BufferedReader(isr);
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
PrintWriter pw = new PrintWriter(bw,true);
//将该输出流存入共享数组allOut中
//1对allOut数组扩容
allOut = Arrays.copyOf(allOut,allOut.length+1);
//2将输出流存入数组最后一个位置
allOut[allOut.length-1] = pw;
String message = null;
while ((message = br.readLine()) != null) {
System.out.println(host + "说:" + message);
//将消息回复给所有客户端
for(int i=0;i<allOut.length;i++) {
allOut[i].println(host + "说:" + message);
}
}
}catch(IOException e){
e.printStackTrace();
}
}
}
}
The client solves the conflict problem of sending and receiving messages
Since the sequence of operations in the client start method is to input a sentence through the console first, send it to the server, and then read the sentence sent back by the server. This results in that if the client does not input content, it cannot receive Other information sent by the server (chat content of other clients). Therefore, the work of receiving messages in the client must be moved to a separate thread for execution, so as to ensure that sending and receiving messages do not interfere with each other.
Client code:
package socket;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
/**
* 聊天室客户端
*/
public class Client {
/*
java.net.Socket 套接字
Socket封装了TCP协议的通讯细节，我们通过它可以与远端计算机建立链接，
并通过它获取两个流(一个输入，一个输出)，然后对两个流的数据读写完成
与远端计算机的数据交互工作。
我们可以把Socket想象成是一个电话，电话有一个听筒(输入流)，一个麦克
风(输出流)，通过它们就可以与对方交流了。
*/
private Socket socket;
/**
* 构造方法，用来初始化客户端
*/
public Client(){
try {
System.out.println("正在链接服务端...");
/*
实例化Socket时要传入两个参数
参数1:服务端的地址信息
可以是IP地址，如果链接本机可以写"localhost"
参数2:服务端开启的服务端口
我们通过IP找到网络上的服务端计算机，通过端口链接运行在该机器上
的服务端应用程序。
实例化的过程就是链接的过程，如果链接失败会抛出异常:
java.net.ConnectException: Connection refused: connect
*/
socket = new Socket("localhost",8088);
System.out.println("与服务端建立链接!");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 客户端开始工作的方法
*/
public void start(){
try {
//启动读取服务端发送过来消息的线程
ServerHandler handler = new ServerHandler();
Thread t = new Thread(handler);
t.setDaemon(true);
t.start();
/*
Socket提供了一个方法:
OutputStream getOutputStream()
该方法获取的字节输出流写出的字节会通过网络发送给对方计算机。
*/
//低级流，将字节通过网络发送给对方
OutputStream out = socket.getOutputStream();
//高级流，负责衔接字节流与字符流，并将写出的字符按指定字符集转字节
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
//高级流，负责块写文本数据加速
BufferedWriter bw = new BufferedWriter(osw);
//高级流，负责按行写出字符串，自动行刷新
PrintWriter pw = new PrintWriter(bw,true);
Scanner scanner = new Scanner(System.in);
while(true) {
String line = scanner.nextLine();
if("exit".equalsIgnoreCase(line)){
break;
}
pw.println(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
/*
通讯完毕后调用socket的close方法。
该方法会给对方发送断开信号。
*/
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Client client = new Client();
client.start();
}
/**
* 该线程负责接收服务端发送过来的消息
*/
private class ServerHandler implements Runnable{
public void run(){
//通过socket获取输入流读取服务端发送过来的消息
try {
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in,"UTF-8");
BufferedReader br = new BufferedReader(isr);
String line;
//循环读取服务端发送过来的每一行字符串
while((line = br.readLine())!=null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
The server completes the operation after the client disconnects
When a client disconnects, the ClientHandler, the thread that handles the client interaction on the server side, should delete the output stream obtained through the socket from the shared array allOut to prevent other ClientHandlers from sending messages to the current client through this output stream .
Server code:
package socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
/**
* 聊天室服务端
*/
public class Server {
/**
* 运行在服务端的ServerSocket主要完成两个工作:
* 1:向服务端操作系统申请服务端口，客户端就是通过这个端口与ServerSocket建立链接
* 2:监听端口，一旦一个客户端建立链接，会立即返回一个Socket。通过这个Socket
* 就可以和该客户端交互了
*
* 我们可以把ServerSocket想象成某客服的"总机"。用户打电话到总机，总机分配一个
* 电话使得服务端与你沟通。
*/
private ServerSocket serverSocket;
/*
存放所有客户端输出流，用于广播消息
*/
private PrintWriter[] allOut = {
};
/**
* 服务端构造方法，用来初始化
*/
public Server(){
try {
System.out.println("正在启动服务端...");
/*
实例化ServerSocket时要指定服务端口，该端口不能与操作系统其他
应用程序占用的端口相同，否则会抛出异常:
java.net.BindException:address already in use
端口是一个数字，取值范围:0-65535之间。
6000之前的的端口不要使用，密集绑定系统应用和流行应用程序。
*/
serverSocket = new ServerSocket(8088);
System.out.println("服务端启动完毕!");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 服务端开始工作的方法
*/
public void start(){
try {
while(true) {
System.out.println("等待客户端链接...");
/*
ServerSocket提供了接受客户端链接的方法:
Socket accept()
这个方法是一个阻塞方法，调用后方法"卡住"，此时开始等待客户端
的链接，直到一个客户端链接，此时该方法会立即返回一个Socket实例
通过这个Socket就可以与客户端进行交互了。
可以理解为此操作是接电话，电话没响时就一直等。
*/
Socket socket = serverSocket.accept();
System.out.println("一个客户端链接了！");
//启动一个线程与该客户端交互
ClientHandler clientHandler = new ClientHandler(socket);
Thread t = new Thread(clientHandler);
t.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Server server = new Server();
server.start();
}
/**
* 定义线程任务
* 目的是让一个线程完成与特定客户端的交互工作
*/
private class ClientHandler implements Runnable{
private Socket socket;
private String host;//记录客户端的IP地址信息
public ClientHandler(Socket socket){
this.socket = socket;
//通过socket获取远端计算机地址信息
host = socket.getInetAddress().getHostAddress();
}
public void run(){
PrintWriter pw = null;
try{
/*
Socket提供的方法:
InputStream getInputStream()
获取的字节输入流读取的是对方计算机发送过来的字节
*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, "UTF-8");
BufferedReader br = new BufferedReader(isr);
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
pw = new PrintWriter(bw,true);
//将该输出流存入共享数组allOut中
//1对allOut数组扩容
allOut = Arrays.copyOf(allOut, allOut.length + 1);
//2将输出流存入数组最后一个位置
allOut[allOut.length - 1] = pw;
//通知所有客户端该用户上线了
sendMessage(host + "上线了,当前在线人数:"+allOut.length);
String message = null;
while ((message = br.readLine()) != null) {
System.out.println(host + "说:" + message);
//将消息回复给所有客户端
sendMessage(host + "说:" + message);
}
}catch(IOException e){
e.printStackTrace();
}finally{
//处理客户端断开链接的操作
//将当前客户端的输出流从allOut中删除(数组缩容)
for(int i=0;i<allOut.length;i++){
if(allOut[i]==pw){
allOut[i] = allOut[allOut.length-1];
allOut = Arrays.copyOf(allOut,allOut.length-1);
break;
}
}
sendMessage(host+"下线了，当前在线人数:"+allOut.length);
try {
socket.close();//与客户端断开链接
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 广播消息给所有客户端
* @param message
*/
private void sendMessage(String message){
for(int i=0;i<allOut.length;i++) {
allOut[i].println(message);
}
}
}
}
The server solves multi-threaded concurrency security issues
In order to forward the callable message to all clients, we added an array-type property allOut on the Server, which is used by all threads ClientHandler. At this time, the operation of the array should consider the issue of concurrency security
When two clients are online at the same time (orange, green)
After the two ClientHandlers are started, they will expand the array and store their own output streams in the array
At this time, ClientHandler (orange) first gets the CPU time to expand the array
CPU switching occurs after capacity expansion, ClientHandler (green) gets the time
At this time, ClientHandler (green) performs array expansion
After the ClientHandler (green) is expanded, the output stream is stored in the last position of the array
The thread switches back to ClientHandler (orange)
ClientHandler (orange) stores the output stream in the last position of the array, and at this time, the input stream stored in ClientHandler (green) will be overwritten. A concurrency security issue has arisen!!
Choose the right lock object
this is not allowed
allOut cannot. In most cases, critical resources can be selected as lock objects, but not here.
ClientHandler (orange) locks allOut
ClientHandler (orange) expansion allOut
Since the array is of fixed length, expansion actually creates a new array, so when the value is assigned to allOut after expansion, the object locked by ClientHandler (orange) will be reclaimed by GC! The newly expanded array does not have a lock.
If thread switching occurs at this time, when ClientHandler (green) locks allOut, it finds that allOut has no lock, so it can lock and execute the synchronized internal code
ClientHandler (green) can also expand the array, so the array it locked before is also reclaimed by GC!
As can be seen from the above code, locking allOut does not restrict multiple threads (ClientHandler) from operating the allOut array, and there are still concurrency security issues.
External class objects can be selected as lock objects, because these internal class ClientHandlers all belong to this external class object Server.this
Also consider the mutual exclusion between different operations on the array, the reason is the same as above. Therefore, the expansion, shrinkage and traversal operations of the allOut array must be mutually exclusive.
Final code:
package socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
/**
* 聊天室服务端
*/
public class Server {
/**
* 运行在服务端的ServerSocket主要完成两个工作:
* 1:向服务端操作系统申请服务端口，客户端就是通过这个端口与ServerSocket建立链接
* 2:监听端口，一旦一个客户端建立链接，会立即返回一个Socket。通过这个Socket
* 就可以和该客户端交互了
*
* 我们可以把ServerSocket想象成某客服的"总机"。用户打电话到总机，总机分配一个
* 电话使得服务端与你沟通。
*/
private ServerSocket serverSocket;
/*
存放所有客户端输出流，用于广播消息
*/
private PrintWriter[] allOut = {
};
/**
* 服务端构造方法，用来初始化
*/
public Server(){
try {
System.out.println("正在启动服务端...");
/*
实例化ServerSocket时要指定服务端口，该端口不能与操作系统其他
应用程序占用的端口相同，否则会抛出异常:
java.net.BindException:address already in use
端口是一个数字，取值范围:0-65535之间。
6000之前的的端口不要使用，密集绑定系统应用和流行应用程序。
*/
serverSocket = new ServerSocket(8088);
System.out.println("服务端启动完毕!");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 服务端开始工作的方法
*/
public void start(){
try {
while(true) {
System.out.println("等待客户端链接...");
/*
ServerSocket提供了接受客户端链接的方法:
Socket accept()
这个方法是一个阻塞方法，调用后方法"卡住"，此时开始等待客户端
的链接，直到一个客户端链接，此时该方法会立即返回一个Socket实例
通过这个Socket就可以与客户端进行交互了。
可以理解为此操作是接电话，电话没响时就一直等。
*/
Socket socket = serverSocket.accept();
System.out.println("一个客户端链接了！");
//启动一个线程与该客户端交互
ClientHandler clientHandler = new ClientHandler(socket);
Thread t = new Thread(clientHandler);
t.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Server server = new Server();
server.start();
}
/**
* 定义线程任务
* 目的是让一个线程完成与特定客户端的交互工作
*/
private class ClientHandler implements Runnable{
private Socket socket;
private String host;//记录客户端的IP地址信息
public ClientHandler(Socket socket){
this.socket = socket;
//通过socket获取远端计算机地址信息
host = socket.getInetAddress().getHostAddress();
}
public void run(){
PrintWriter pw = null;
try{
/*
Socket提供的方法:
InputStream getInputStream()
获取的字节输入流读取的是对方计算机发送过来的字节
*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, "UTF-8");
BufferedReader br = new BufferedReader(isr);
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
pw = new PrintWriter(bw,true);
//将该输出流存入共享数组allOut中
// synchronized (this) {//不行，因为这个是ClientHandler实例
// synchronized (allOut) {//不行，下面操作会扩容，allOut对象会变
synchronized (Server.this) {
//外部类对象可以
//1对allOut数组扩容
allOut = Arrays.copyOf(allOut, allOut.length + 1);
//2将输出流存入数组最后一个位置
allOut[allOut.length - 1] = pw;
}
//通知所有客户端该用户上线了
sendMessage(host + "上线了,当前在线人数:"+allOut.length);
String message = null;
while ((message = br.readLine()) != null) {
System.out.println(host + "说:" + message);
//将消息回复给所有客户端
sendMessage(host + "说:" + message);
}
}catch(IOException e){
e.printStackTrace();
}finally{
//处理客户端断开链接的操作
//将当前客户端的输出流从allOut中删除(数组缩容)
synchronized (Server.this) {
for (int i = 0; i < allOut.length; i++) {
if (allOut[i] == pw) {
allOut[i] = allOut[allOut.length - 1];
allOut = Arrays.copyOf(allOut, allOut.length - 1);
break;
}
}
}
sendMessage(host+"下线了，当前在线人数:"+allOut.length);
try {
socket.close();//与客户端断开链接
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 广播消息给所有客户端
* @param message
*/
private void sendMessage(String message){
synchronized (Server.this) {
for (int i = 0; i < allOut.length; i++) {
allOut[i].println(message);
}
}
}
}
}
collection framework
what is collection
Collections, like arrays, can store a set of elements, and provide methods for manipulating elements, which are more convenient to use.
Related interfaces in java collection framework
java.util.Collection interface:
java.util.Collection is the top-level interface of all collections. There are multiple implementation classes under Collection, so we have more data structures to choose from.
There are two common sub-interfaces under Collection:
- java.util.List: Linear table. It is a repeatable collection and ordered.
- java.util.Set: non-repeatable collection, most implementation classes are unordered.
Repeatability here refers to whether the elements in the collection can be repeated, and the criterion for determining repeated elements is to rely on the element's own equals comparison
The result. If it is true, it is considered to be a repeated element.
package collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
/*
boolean add(E e)
向当前集合中添加一个元素.当元素成功添加后返回true
*/
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
/*
int size()
返回当前集合的元素个数
*/
int size = c.size();
System.out.println("size:"+size);
/*
boolean isEmpty()
判断当前集合是否为空集(不含有任何元素)
*/
boolean isEmpty = c.isEmpty();
System.out.println("是否为空集:"+isEmpty);
/*
清空集合
*/
c.clear();
System.out.println(c);
System.out.println("size:"+c.size());//0
System.out.println("是否为空集:"+c.isEmpty());
}
}
Collection and element equals method related methods
package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
* 集合的很多操作有与元素的equals方法相关。
*/
public class CollectionDemo2 {
public static void main(String[] args) {
// Collection c = new ArrayList();
Collection c = new HashSet();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(7,8));
c.add(new Point(1,2));
/*
集合重写了Object的toString方法，输出的格式为:
[元素1.toString(), 元素2.toString(), ....]
*/
System.out.println(c);
Point p = new Point(1,2);
/*
boolean contains(Object o)
判断当前集合是否包含给定元素，这里判断的依据是给定元素是否与集合
现有元素存在equals比较为true的情况。
*/
boolean contains = c.contains(p);
System.out.println("包含:"+contains);
/*
remove用来从集合中删除给定元素，删除的也是与集合中equals比较
为true的元素。注意，对于可以存放重复元素的集合而言，只删除一次。
*/
c.remove(p);
System.out.println(c);
}
}
Collections store references to elements
Collections can only store reference type elements, and store references to elements
package collection;
import java.util.ArrayList;
import java.util.Collection;
/**
* 集合只能存放引用类型元素，并且存放的是元素的引用(地址)
*/
public class CollectionDemo3 {
public static void main(String[] args) {
Collection c = new ArrayList();
Point p = new Point(1,2);
c.add(p);
System.out.println("p:"+p);//p:(1,2)
System.out.println("c:"+c);//c:[(1,2)]
p.setX(2);
System.out.println("p:"+p);//p:(2,2)
System.out.println("c:"+c);//c:[(2,2)]
}
}
