Java初级笔记No.4（更新中）
2018.7.27
1、Java的主要内置数据结构包括：枚举（Enumeration），位集合（BitSet），向量（Vector）， 栈（Stack）， 字典（Dictionary）， 哈希表（Hashtable）， 属性（Properties）。
枚举（Enumeration）
枚举接口定义了一种从数据结构中取回连续元素的方式。例如，枚举定义了一个叫nextElement的方法，该方法用来得到一个包含多个元素的数据结构的下一个元素，在这一点上很像是C++中的迭代器。
而事实上，这种传统接口确实已经被迭代器取代了，在现在代码中已经很少被使用了。
import java.util.Vector;
import java.util.Enumeration;
public class EnumerationTester {
public static void main(String[] args) {
Enumeration<String> days;
Vector<String> dayNames = new Vector<String>();
dayNames.add("Sunday");
dayNames.add("Monday");
dayNames.add("Tuesday");
dayNames.add("Wednesday");
dayNames.add("Thursday");
dayNames.add("Friday");
dayNames.add("Saturday");
days = dayNames.elements();
while (days.hasMoreElements()) {
System.out.println(days.nextElement());
}
}
}
位集合（BitSet）
位集合实现了一组可以单独设置和清除的位或标志。
该类在处理一组Boolean值的时候非常有用，只需要给每个值赋予一位，然后对位进行相应的设置或清除，就可以对布尔值进行操作了。
import java.util.BitSet;
public class BitSetDemo {
public static void main(String[] args) {
BitSet bits1 = new BitSet(16);
BitSet bits2 = new BitSet(16);
// set some bits
for (int i = 0; i < 16; ++i) {
if (i % 2 == 0) bits1.set(i);
if (i % 5 != 0) bits2.set(i);
}
System.out.println("Initial pattern in bits1 : ");
System.out.println(bits1);
System.out.println("Initial pattern in bits2 : ");
System.out.println(bits2);
// AND bits
bits2.and(bits1);
System.out.println("bits2 AND bits1 : ");
System.out.println(bits2);
// OR bits
bits2.or(bits1);
System.out.println("bits2 OR bits1 : ");
System.out.println(bits2);
// XOR bits
bits2.xor(bits1);
System.out.println("bits2 XOR bits1 : ");
System.out.println(bits2);
}
}
向量（Vector）
向量类和传统数组非常类似，但是Vector的大小能根据需要动态的变化。
与C++STL中的vector中不同，Java的Vector中可以存储不同类型的元素：
import java.util.*;
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector(3,2);
System.out.println("Initial size : " + v.size());
System.out.println("Initial capacity : " + v.capacity());
v.addElement(new Integer(1));
v.add(2);
v.add(3);
v.add(4);
System.out.println("Capacity after four additions:" + v.capacity());
v.addElement(new Double(5.45));
v.addElement(new String("haha"));
Enumeration vEnum = v.elements();
System.out.println("Elements in vector:");
while (vEnum.hasMoreElements()) {
System.out.println(vEnum.nextElement() + " ");
}
System.out.println();
}
}
栈（Stack）
package test3;
import java.util.*;
public class StackDemo {
static void showpush(Stack<Integer> st, int a) {
st.push(new Integer(a));
System.out.println("push(" + a + ")");
System.out.println("stack: " + st);
}
static void showpop(Stack<Integer> st) {
System.out.print("pop -> ");
Integer a = (Integer) st.pop();
System.out.println(a);
System.out.println("stack : " + a);
}
public static void main(String[] args) {
Stack<Integer> st = new Stack<Integer>();
System.out.println("stack : " + st);
showpush(st, 42);
showpush(st, 66);
showpush(st, 99);
showpop(st);
showpop(st);
showpop(st);
try {
showpop(st);
} catch (EmptyStackException e) {
System.out.println("empty stack");
}
}
}
字典（Dictionary）
字典类定义了键映射到值的数据结构。
其实Dictionary已经过时了，在实际开发中应该使用Map接口来实现k-v的存储功能。
package test3;
import java.util.*;
public class MapDemo {
public static void main(String[] args) {
Map m1 = new HashMap();
m1.put("Zara", "8");
m1.put("Mahnaz", "31");
m1.put("Ayan", "12");
m1.put("Daisy", "14");
System.out.println();
System.out.println("Map Elements");
System.out.println(m1);
System.out.println(m1.get("Zara"));
}
}
哈希表（Hashtable）
Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。
例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。
其实Hashtable就是Dictionary的具体实现，与HashMap类很相似，但是其支持同步。
package test3;
import java.util.*;
public class HashTableDemo {
public static void main(String[] args) {
//Create a hash
Hashtable balance = new Hashtable();
Enumeration names;
String str;
double bal;
balance.put("Zara", new Double(3434.34));
balance.put("Mahnaz", new Double(123.22));
balance.put("Ayan", new Double(1378.00));
balance.put("Daisy", new Double(99.22));
balance.put("Qadir", new Double(-19.08));
// Show all balances in hash table
names = balance.keys();
while (names.hasMoreElements()) {
str = (String) names.nextElement();
System.out.println(str + ": " + balance.get(str));
}
System.out.println();
//Deposit 1000 into Zara's account
bal = ((Double)balance.get("Zara")).doubleValue();
balance.put("Zara", new Double(bal+1000));
System.out.println("Zara's new balance:" + balance.get("Zara"));
}
}
属性（Properties）
Properties继承于Hashtable。表示一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。
import java.util.*;
public class PropDemo {
public static void main(String args[]) {
Properties capitals = new Properties();
Set states;
String str;
capitals.put("Illinois", "Springfield");
capitals.put("Missouri", "Jefferson City");
capitals.put("Washington", "Olympia");
capitals.put("California", "Sacramento");
capitals.put("Indiana", "Indianapolis");
// Show all states and capitals in hashtable.
states = capitals.keySet(); // get set-view of keys
Iterator itr = states.iterator();
while(itr.hasNext()) {
str = (String) itr.next();
System.out.println("The capital of " +
str + " is " + capitals.getProperty(str) + ".");
}
System.out.println();
// look for state not in list -- specify default
str = capitals.getProperty("Florida", "Not Found");
System.out.println("The capital of Florida is "
+ str + ".");
}
}
2、Java集合框架
集合框架被设计成要满足以下几个目标：
· 该框架必须是搞性能的，基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的；
· 该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性；
· 对一个集合的扩展和适应必须是简单的。
集合框架是一个用来代表和操纵集合的同一架构。所有的集合框架都包含如下内容：
· 接口：代表集合的首先数据类型。例如Collection、List、Set、Map等。之所以定义多个接口，是为了以不同方式操作集合对象；
· 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，如ArrayList、LinkedList、HashSet、HashMap；
· 算法： 是实现集合接口的对象里的方法执行的一些有用的算法， 如搜索和排序，这些算法被称为多态，那是因为相同的方法可以在相似的接口上有不同的实现。
3、使用迭代器
迭代器，能够通过血环来得到或删除集合的元素。如ListIterator继承了Iterator，以允许双向遍历列表和修改元素。
遍历ArrayList
package test3;
import java.util.*;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");
// 第一种遍历方法，使用foreach遍历List
for (String str : list) {
System.out.println(str);
}
//第二种遍历方式，将链表变为数组相关的内容
String[] strArray = new String[list.size()];
list.toArray(strArray);
for (int i = 0; i < strArray.length; ++i) {
System.out.println(strArray[i]);
}
//第三种遍历方式，使用Iterator
Iterator<String> ite = list.iterator();
while (ite.hasNext()) {
System.out.println(ite.next());
}
}
}
遍历Map
package test3;
import java.util.*;
public class Test {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");
//第一种遍历方法，普遍使用，二次取值
System.out.println("通过Map.keySet遍历key和value:");
for (String key : map.keySet()) {
System.out.println("key = " + key + " and value = " + map.get(key));
}
//第二种遍历方式
System.out.println("通过Map.entrySet使用iterator遍历key和value:");
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key=" + entry.getKey() + " and value=" + entry.getValue());
}
//第三种遍历方式，推荐，尤其是在容量大时
System.out.println("通过Map.entrySet遍历key和value:");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key=" + entry.getKey() + " and value=" + entry.getKey());
}
//第四种遍历方式
System.out.println("通过Map.values()遍历所有的value，但是不能得到key:");
for (String v : map.values()) {
System.out.println("value = " + v);
}
}
}
4、了解Java泛型
泛型的概念与C++中的泛型没有区别，这是一种程序设计思想。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。
下面是定义泛型方法的规则：
· 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前；
· 每一个类型参数声明部分包含一个或多个类型参数，参数见用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符；
· 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符；
· 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用类型，不能是原始类型（如int，double，char等）。
实例
下面的例子演示了如何使用泛型方法打印不同字符串的元素：
public class GenericMethodTest {
//泛型方法 printArray
public static <E> void printArray(E[] inputArray) {
//
for (E element : inputArray) {
System.out.printf("%s", element);
}
System.out.println();
}
public static void main(String[] args) {
Integer[] intArray = {1,2,3,4,5};
Double[] doubleArray = {1.1,2.2,3.3,4.4,5.5};
Character[] charArray = {'H', 'E', 'L', 'L', 'O'};
System.out.println("Integer : ");
printArray(intArray);
System.out.println("Double : ");
printArray(doubleArray);
System.out.println("Character : ");
printArray(charArray);
}
}
有界的参数实例
有时候，我们会想限制那些被允许传递到一个类型参数的类型种类范围，例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。者就是有界类型参数的目的。
首先需要列出参数类型的名称，后面跟extends或者implements：
package test2;
public class MaximumTest {
/*返回三个可被Comparable的最大值*/
public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
T max = x;
if (y.compareTo(max) > 0)
max = y;
if (z.compareTo(max) > 0)
max = z;
return max;
}
public static void main(String[] args) {
System.out.printf("%d, %d, %d 中最大的数为：%d\n\n", 3,4,5,maximum(3,4,5));
System.out.printf("%.1f, %.1f, %.1f 中最大的数为：%.1f\n\n", 6.6,8.8,7.7, maximum(6.6,8.8,7.7));
System.out.printf("%s, %s, %s 中最大的数为： %s\n\n", "apple", "pear", "orange", maximum("apple", "pear", "orange"));
}
}
5、泛型类
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数见用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
package test2;
public class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("LiMing"));
System.out.println("Integer:" + integerBox.get());
System.out.println("String:" + stringBox.get());
}
}
6、类型通配符
类型通配符一般是使用?代替具体类型参数。例如List<?>在逻辑上是List<String>, List<Integer>, 等所有List<>的父类：
package test2;
import java.util.*;
public class GenericTest {
public static void main(String[] args) {
List<String> name = new ArrayList<String>();
List<Integer> age = new ArrayList<Integer>();
List<Number> number = new ArrayList<Number>();
name.add("icon");
age.add(18);
number.add(314);
getData(name);
getData(age);
getData(number);
}
public static void getData(List<?> data) {
System.out.println(data.get(0));
}
}
因为getData()这个方法的参数是List<?>类型的，所以name,age,number都可以作为这个方法的实参，这就是通配符的作用。
同理，也可以限定类型通配符上限，例如令其只能接受Number及其下层子类类型：
public static void getData(List<? extends Number> data) {
System.out.println(data.get(0));
}
这样的话，对于String类型的name就会报错。
7、Java序列化
Java中提过了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括了该对象的数据、有关对象的类型的信息和存储在对象中的数据的类型。
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
这个过程都是JVM实现的，也就是说，在一个平台上序列化的对象可以在另一个平台上完成反序列化。
类ObjectInputStream和ObjectOutputStream是高层次的数据流，它们包含反序列化和序列化对象的方法。
该方法序列化一个对象，并将它发送到输出流。
public final void writeObject(Object x) throws IOException
readObject()方法可以反序列化一个对象，它的返回值是Object，因此需要将它转化成何时的数据类型：
public final Object readObject() throws IOException ClassNotFoundException
实例
一个类的对象要向序列化成功，必须满足两个条件：
· 该类必须实现java.io.Serializable接口；
· 该类的所有属性必须是可序列化的。
public class Employee implements java.io.Serializable {
public String name;
public String address;
public transient int SSN; //不包含在序列化表示中
public int number;
public void mailCheck() {
System.out.println("Mailing a check to " + name + " " + address);
}
}
ObjectOutputStream类用来序列化一个对象，如下的SerializeDemo例子实例化了上面的Employee对象，并将该对象序列化到了一个文件中。
改程序执行后，会创建一个名为employee.ser文件，当然也可以为.txt文件。
import java.io.*;
public class SerializeDemo {
public static void main(String[] args) {
Employee e = new Employee();
e.name = "LiMing";
e.address = "BeiJing";
e.SSN = 11122333;
e.number = 101;
try {
FileOutputStream fileOut = new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e); //序列化
out.close();
fileOut.close();
System.out.println("Serialized data is saved in /tmp/employee.ser");
} catch(IOException i) {
i.printStackTrace();
}
}
}
下面的DeserializeDemo程序实现了反序列化：
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Name: " + e.name);
System.out.println("Address: " + e.address);
System.out.println("SSN: " + e.SSN);
System.out.println("Number: " + e.number);
}
}
运行结果为：
由于属性SSN被设置为了transient，表示为短暂的，不会被发送到输出流，也就不会参与序列化，所以反序列化后的SSN属性为0。
8、Java中的Socket编程
在java中java.net.Socket代表一个套接字，并且java.net.ServerSocket类为服务器程序提供了一种来监听客户端，并建立连接的机制。
java中Socket编程的基本步骤如下：
· 服务器实例化一个ServeSocket对象，表示通过服务器上的端口通信。
· 服务器调用ServerSocket类的accept方法，该方法将一直等待，知道客户端连接到服务器上给定的端口；
· 服务器正在等待，一个客户端实例化一个Socket对象，指定服务器名称和端口号来请求连接；
· Socket类的构造函数视图将客户端连接到指定的服务器和端口。如果通信被简历，则客户端创建一个Socket对象能够与服务器进行通信；
· 在服务器端，accept()方法返回服务器上一个新的socket引用，该socket连接到客户端的socket；
连接建立后，通过使用I/O流在进行通信，每一个socket都有一个输出流和一个输入流，客户端的输出流连接服务器端的输入流，而客户端的输入流连接服务器端的输出流。
/*client*/
import java.net.*;
import java.io.*;
public class GreetingClient {
public static void main(String[] args) {
String serverName = args[0];
int port = Integer.parseInt(args[1]);
try {
System.out.println("连接到主机：" + serverName + ", 端口号：" + port);
Socket client = new Socket(serverName, port);
System.out.println("远程主机地址：" + client.getRemoteSocketAddress());
OutputStream outToServer = client.getOutputStream();
DataOutputStream out = new DataOutputStream(outToServer);
out.writeUTF("Hello from " + client.getLocalSocketAddress());
InputStream inFromServer = client.getInputStream();
DataInputStream in = new DataInputStream(inFromServer);
System.out.println("服务器响应：" + in.readUTF());
client.close();
} catch(IOException e) {
e.printStackTrace();
}
}
}
/*server*/
import java.net.*;
import java.io.*;
public class GreetingServer extends Thread {
private ServerSocket serverSocket;
public GreetingServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
serverSocket.setSoTimeout(10000);
}
public void run() {
while (true) {
try {
System.out.println("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "...");
Socket server = serverSocket.accept();
System.out.println("远程主机地址：" + server.getRemoteSocketAddress());
DataInputStream in = new DataInputStream(server.getInputStream());
System.out.println(in.readUTF());
DataOutputStream out = new DataOutputStream(server.getOutputStream());
out.writeUTF("谢谢连接我：" + server.getLocalSocketAddress() + "Goodbye!");
server.close();
} catch(SocketTimeoutException s) {
System.out.println("Socket timed out!");
break;
} catch(IOException e) {
e.printStackTrace();
break;
}
}
}
public static void main(String[] args) {
int port = Integer.parseInt(args[0]);
try {
Thread t = new GreetingServer(port);
t.run();
} catch(IOException e) {
e.printStackTrace();
}
}
}
