- 集合框架和泛型
- 实用类(包装类, Math, String大类, java.util<日期时间, Random>);
- 输入/输出和反射
- XML技术
- 网络编程技术
- 注解和多线程
一. 集合框架
1. List接口
- ArrayList(动态数组)
- LinkedList(链表)
2. Set接口
- HashSet
- 不能保存重复的对象, 没有顺序, 进出的顺序可能是不同的;
- 允许集合元素值为null;
- 独特方法: boolean contains(Object obj)
- Set因为没有数组index, 因此只能使用增强型for循环, 或者是iterator
- Iterator
- 使用简单, 专门为集合设计
//list.iterator, it.hasNext(), it.next()这三个是关键;
Iterator it = list.iterator();
while(it.hasNext()) {
String name = (String) it.next();
System.out.println(name);
}
3. Map接口
- HashMap
- 特点: 查询制定元素的效率很高;
- key没有顺序, 不许重复; value没有顺序, 允许重复; 形成的是映射关系;
4. 泛型
- 本质就一句话: 对类型进行参数化, 集合框架里面, 比如ArrayList, Set, Map中往往参数约定是Object, 太宽泛, 用泛型可以进行约束, 免除转换类型的麻烦;
二. 实用类
- java.lang, java.util两个包的内容
- (包装类, Math, String大类, java.util<日期时间, Random>);
包装类
- 用途: 做类型转换的时候, 包装类非常好用;
- 类型转换如果是从Object这样的大类往小类(Person)转化, 那么直接在前面写(Person) obj 就行;
- 如果是比如String往int转, 那么要用到包装类, String-->int直接+""就可以了;
/*String-->int*/
Integer num1 = Integer.valueOf("20");
System.out.println(num1+5);
//结果: 25;
/*包装类型转化成基本类型*/
int num2;
Integer num3 = 30;
//num3现在是对象, 有方法可以调出;
int num4 = num3; //简单(✔️)
int num5 = num3.intValue(); //传统
//num4现在是基本数据类型, 没有方法;
Math
- Math.abs(double a)
- Math.max(double a, double b)
- Math.random() //返回一个取值为[0, 1.0)的随机值, 在java.util中其实还有一个专门的Random类
//课堂代码
/*16 choose 1*/
int blue = random = (int)(Math.random()*16+1); //random∈[1, 16];
//int自动去掉尾数, (int)1.79 = 1;
String (week09)
- String不是基本类型, 而是作为一个对象来处理;
- 常用方法:
- str1.concat(str2) 或者str1+str2 //连接
- str.indexOf(String value) //查找
- str.substring(int beginindex[, int endindex]); //提取
- str.split(separator[, limit]) //使用指定符号进行分割, 比如逗号, 分号, 空格;
StringBuffer(常用)
- StringBuffer sb = new StringBuffer(str);
- sb.append(任何类型) //可以追加int, double等;
- sb.insert(index, 任何类型) //类似数组的插入;
- String str = sb.toString();
util包中的常用类(日期时间+Random)
日期时间类
//典型用例, 只要参照这个就可以了;
//注意, Date已经过期, 一律使用Calendar来处理;
Calendar cal = Calendar.getInstance(); //当前时间;
Calendar cal1 = Calendar.getInstance();
cal1.set(2012, 12-1, 20, 19, 55, 40); //自己设定时间;
SimpleDateFormat formater =
new SimpleDateFormat("日期:yyyy/MM/dd 时间:HH:mm:ss");
System.out.println(cal.getTime());
System.out.println(formater.format(cal.getTime()));
System.out.println(cal1.getTime());
System.out.println(formater.format(cal1.getTime()));
三. 输入/输出(I/O)和反射
- File* (不常用, 看API即可)
- FileInputStream, FileReader+BufferedReader/readLine,
- FileInputStream+DataInputStream,
- Serializable接口, ObjectInputStream/readObject;
1. 读写文本文件 (week09)
- 定义: Stream, 流, 以先进先出的方式发送和接收数据的通道;
- Octet Stream 八位流 InputStream
- Unicode Stream 十六位流 Reader
FileInputStream
关键步骤:
(开)建立byte[]数组, fis.available(),
(取)fis.read(by), fos.write(by),
(关)fis.close(), fos.close();
/*典型用例: 复制文本文件*/
fos.close
public static void inputAndOutputStream() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("/Users/Chen/Downloads/code.xml");
fos = new FileOutputStream("/Users/Chen/Downloads/codeCopy.xml");
int length = fis.available();
byte[] by = new byte[length];
fis.read(by); //将数据读取到字节数组中;
fos.write(by);
System.out.println("Copy done!");
fis.close();
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
FileReader+BufferedReader/readLine
关键步骤
(开)BufferedReader获取FileReader对象;
(取)readLine;
while line!= null wr.write(line); wr.newLine(); line=readLine()
(关)rd.close(); wr.flush(); wr.close();
public static void buffered() throws FileNotFoundException, IOException {
BufferedReader rd =
new BufferedReader(new FileReader("/Users/Chen/Downloads/code.xml"));
BufferedWriter wr =
new BufferedWriter(new FileWriter("/Users/Chen/Downloads/codeCopy2_buffered.xml"));
String line = rd.readLine();
while (line!=null) {
wr.write(line);
wr.newLine();
line = rd.readLine();
}
System.out.println("Copy done!");
rd.close();
wr.flush();
wr.close();
}
2. 读写Data二进制文件
关键步骤
(开)用DataInputStream获取FileInputStream
(取)byte[] by数组来取, dis.read(by); dos.write(by);
(关)dis.close(), dos.close();
private static void dataInputOutputStream() {
DataInputStream dis = null;
DataOutputStream dos = null;
try {
dis = new DataInputStream(new FileInputStream("/Users/Chen/Downloads/java.jpg"));
dos = new DataOutputStream(new FileOutputStream("/Users/Chen/Downloads/javaCopy0.jpg"));
/*创建一个by[length]来存储*/
int length = dis.available();
byte[] by = new byte[length];
/*read to by and write from by to file*/
dis.read(by);
dos.write(by);
System.out.println("Copy done!");
} catch(Exception e) {
e.printStackTrace();
} finally {
try {
dis.close(); dos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. 读写对象: 序列化与反序列化
读写对象用的最多, 却最简单;
关键步骤:
(开) 用ObjectInputStream获取FileInputStream对象;
(取) Student stu = (Student) ois.readObject(); //记得强转readObject获得的对象
oos.writeObject(stu);
(关) ois.close(); oos.close();
XML技术
1. XML文档结构
//开头约定
Yesterday
Beattles
2. DTD* //需要的时候再参阅
//*代表量词(0~n)
//允许包含名称和教师标签
//允许包含任何内容, 但是不能有子标签
3. DOM操作XML
public void addNode() throws Exception {
Document dc = getDoc();
//创建节点, 设置content和attr;
Element dateTag = dc.createElement("date");
dateTag.setTextContent("2016年");
dateTag.setAttribute("remark", "important");
//获得student[1]
Element sTag_1 = (Element)dc.getElementsByTagName("student").item(1);
//appendChild
sTag_1.appendChild(dateTag);
//写入XML中
writeXML(dc);
}
网络编程技术+注解和多线程
- 这两部分在案例中往往一起使用;
- 每个进程配一个端口;
- TCP协议: 先建立连接后才能开始双向地(叫作双工)交换数据;
- socket: 网络驱动层提供给应用程序的接口, 类似于快递站, 程序员只要把数据包裹交给socket就trouble-free了. 因此我们对socket的应用也主要是将ois和oos对接到socket这个"快递点"即可.
Socket通信
-服务器
- ServerSocket, socket, //ois/oos, input and output, //close
-客户端Client - Socket, //先oos再ois, output and input, //close;
- 核心: 把输入输出流的目标和来源写成socket;
简单案例: 简单建立连接
//服务器
ServerSocket serverSocket = new ServerSocket(5500);
System.out.println("Server is on...");
Socket socket = serverSocket.accept();
System.out.println("监听到客户端连接!"+socket.getRemoteSocketAddress());
//先初始化输入, 再初始化输出, 顺序没有影响;
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
System.out.println((String) ois.readObject());
oos.writeObject("S to C: Hello client!");
//客户端
Socket socket = new Socket("localhost", 5500);
System.out.println("Client is on!");
//先初始化输出, 再初始化输入, 顺序有影响;
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
oos.writeObject("C to S: Hello Server!");
System.out.println((String)ois.readObject());
复杂案例: 单服务器提供多线程给多个客户端
//服务器
/*Server*/
public class Server {
public static void main(String[] args) {
ServerSocket ssocket = null;
try {
ssocket = new ServerSocket(5600);
Socket socket = null;
System.out.println("Server on...");
while (true) {
socket = ssocket.accept();
System.out.println("Connection established with"+socket.getRemoteSocketAddress());
ServerThread st = new ServerThread(socket);
st.start();
}
//-------------------------------------------------------------接下去记得close就可以
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (ssocket!=null) {
ssocket.close();
}
}catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*ServerThread*/
public class ServerThread extends Thread{ //记得是继承了Thread抽象类
public Socket socket; //之所以在属性, 是因为构造方法的需要
public ServerThread() {
super();
}
public ServerThread(Socket socket) {
super();
this.socket = socket; //构造方法里面需要socket
}
@Override
public void run() { //override run方法
ObjectInputStream ois = null;
ObjectOutputStream oos = null;
try {
ois = new ObjectInputStream(socket.getInputStream());
oos = new ObjectOutputStream(socket.getOutputStream());
System.out.println((String)ois.readObject());
oos.writeObject("from Server to Client: How are you?");
//--------------------------------------接下去记得close就可以
} catch (Exception e) {
e.printStackTrace();
} finally {
if (socket!=null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (oos!=null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (ois!=null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
//客户端
/Client/
public class Client {
public static void main(String[] args) {
Socket socket = null;
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
socket = new Socket("localhost", 5600);
oos = new ObjectOutputStream(socket.getOutputStream()); //必须先给oos指定对象, 否则无法传输数据;
ois = new ObjectInputStream(socket.getInputStream());
oos.writeObject("from Client to Server: Hi, I am a client!");
System.out.println((String)ois.readObject());
//-----------------------------------------------------接下去只要记得关闭网络接口和流就行了;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (socket!=null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}