数据结构
枚举（Enumeration）
enum color
{
red,blue,green
}
color.red //取单个值
color.values() //['red','blue','green']
color.ordinal("red") //0
向量（Vector）
向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化，在创建对象的时候不必给对象指定大小
//四种构造方法
Vector() //创建一个默认的向量，默认大小为 10
Vector(int size) //创建指定大小的向量
Vector(int size,int incr) //创建size大小的向量,每次增加的incr个元素数目
Vector(Collection c) //创建一个包含集合 c 元素的向量
//方法
v.size() //返回此向量中的组件数,初始化向量的size=0
v.capacity() //向量的当前容量
v.addElement(new Integer(1)) //添加
(Integer)v.firstElement()
(Integer)v.lastElement()
Enumeration vEnum = v.elements()
vEnum.hasMoreElements() //boolean
vEnum.nextElement()
v.contains(new Integer(3)) //boolean
栈（Stack）
后进先出（LIFO）的数据结构
Stack<Integer> st = new Stack<Integer>()
st.push(new Integer(42)) //入栈
st.pop() //出栈，并且移除
st.peek() //出栈，不移除
st.empty() //boolean，是否为空
st.search(new Integer(42)) //返回对象在堆栈中的位置，以 1 为基数
if(!st.empty()) {
System.out.print(st.search(12)); //3
}
字典
Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似，通过特定的键而不是整数索引来访问数据，Dictionary类已经过时了。在实际开发中，你可以实现Map接口来获取键/值的存储功能
Map m=new HashMap();
m.put("a", 12);
m.put("b", 13);
m.put("c", 14);
m.put("d", 15);
if(!m.isEmpty()) {
System.out.println(m.size()); //4
Collection<String> keys=m.values(); //[12, 13, 14, 15]
Set<Integer> vaSet=m.keySet(); //[a, b, c, d] 无序的，不重复的数据
//检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变，HashSet,TreeSet
m.remove("a"); //{b=13, c=14, d=15}
System.out.println(m.get("b")); //13
}
哈希表（Hashtable）
在用户定义键结构的基础上来组织数据的手段,例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名
//Hashtable定义了四个构造方法
Hashtable() //默认构造方法
Hashtable(int size)//创建size大小的哈希表
Hashtable(int size,float fillRatio)//创建了一个填充比例为fillRatio的size大小的哈希表
Hashtable(Map m)//以M中元素为初始化元素，哈希表的容量为M的两倍
//方法
Hashtable balance = new Hashtable();
balance.put("Zara", new Double(3434.34));
balance.get("Zara")
balance.remove("Zara")
balance.size()
Enumeration keys=balance.keys( ) //键
Enumeration vaset=balance.elements( ) //值
banlance.isEmpty()
属性
Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串
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.setProperty("test", "good");
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 + ".");
}
}
任何对象加入集合类（java.util包俩米娜的类和接口）后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换
集合框架
ArrayList
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素
import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类
ArrayList<String> sites = new ArrayList<String>(); //[Google]
sites.add("Google"); //增
sites.get(0)//查
sites.set(0, "Wiki")//改
sites.remove(0)//删
sites.size()
Collections.sort(sites); // 首字母排序，正序
//Collections 类也是一个非常有用的类，提供了对集合进行排序、遍历等多种算法实现
HashSet<Integer> set = new HashSet<>() //[1, 2, 3]
ArrayList<Integer> s1 = new ArrayList<Integer>(); //[5,6]
s1.addAll(1,set) //[ 5, 1, 2, 3, 6]
s1.addAll(set) //[5, 6, 1, 2, 3] ,没有说明，就在末尾插入
s1.removeAll(set) //[1, 2, 3],删除数组元素
sites.clear(); // 删除所有元素 []
ArrayList<String> cloneSites = (ArrayList<String>)sites.clone() // 对 sites 进行拷贝
sites.contains(1) // 检查 1 是否在这个数组中 true
sites.indexOf(1) //索引位置0
sites.subList(1, 3) //子串[1:3] = [1,3)
sites.toArray(arr) //String[] arr
// 将所有元素更改为大写
sites.replaceAll(e -> e.toUpperCase())
// 所有元素乘以 2
sites.replaceAll(e -> e * 2); //括号里面是Lambda表达式，把函数作为一个方法的参数
// 删除名称中带有 Tao 的元素
sites.removeIf(e -> e.contains("Tao"))
//forEach() 方法用于遍历动态数组中每一个元素并执行特定操作
numbers.forEach((e) -> {e = e * 10;System.out.print(e + " ");}); //每个元素乘以10
链表 LinkedList
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add(2,"Taobao");
s1.addAll(1,set); //类似于arraylist，添加数组
s1.addAll(set); //指定位置添加数组
sites.addFirst("Wiki"); // 使用 addFirst() 在头部添加元素
sites.offerFirst("happy"); //头部插入元素，返回是否成功，成功为 true，失败为 false。
sites.offerLast("good"); //尾部添加元素，返回是否成功，成功为 true，失败为 false
sites.addLast("Wiki"); // 使用 addLast() 在尾部添加元素
sites.removeFirst(); // 使用 removeFirst() 移除头部元素
sites.removeLast(); // 使用 removeLast() 移除尾部元素
sites.getFirst(); // 使用 getFirst() 获取头部元素
sites.getLast(); // 使用 getLast() 获取尾部元素
sites.size(); //3
sites.get(1); //Runoob
sites.remove(0); //删除索引为0 的数据
sites.clear();
sites.poll(); //删除并返回第一个元素。
sites.remove(); //删除并返回第一个元素。
sites.indexOf("good");//查找指定元素从前往后第一次出现的索引
sites.lastIndexOf("happy");//查找指定元素最后一次出现的索引
sites.set(1,"food");//设置指定位置的元素
HashSet
HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合,但是允许有 null 值，HashSet是无序的，即不会记录插入的顺序
HashSet<String> sites = new HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Google"); //[Google, Runoob],不允许有重复的数据
sites.contains("Google");//true
sites.remove("Google"); // 删除元素，删除成功返回 true，否则为 false
sites.clear();
sites.size()
HashMap
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射,无序的，即不会记录插入的顺序
HashMap 的 key 与 value 类型可以相同也可以不同，可以是字符串（String）类型的 key 和 value，也可以是整型（Integer）的 key 和字符串（String）类型的 value
//Integer, String两两组合
HashMap<Integer, String> Sites = new HashMap<Integer, String>();
Sites.put(1, "Google");
Sites.get(3) //通过键取值
Sites.remove(4); // 通过键删除
Sites.clear();
Sites.size()
// 输出 key 和 value
for (Integer i : Sites.keySet()) {
System.out.println("key: " + i + " value: " + Sites.get(i));
}
// 返回所有 value 值
for(String value: Sites.values()) {
// 输出每一个value
System.out.print(value + ", ");
}
// 将所有的映射关系从 sites 添加到 sites2
sites2.putAll(sites);
sites.isEmpty(); // false
sites.containsKey(1) //是否包含键1 boolean
sites.containsValue("Runoob") //是否包含值Runoob boolean
String value = sites.replace(2, "Wiki") //value等于原来的Runoob 旧的Runoob变成Wiki
//或者hashmap.replace(K key, V oldValue, V newValue)
sites.replace(1, "Google", "Wiki"); // 返回 true
//如果 key 对应的 value 不存在，则返回该 value 值，如果存在，则返回通过 remappingFunction 重新计算后的值
//hashmap.merge(key, value, remappingFunction)
int returnedValue = sites.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue);
Iterator（迭代器）
Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合
迭代器的两个基本操作是 next 、hasNext 和 remove
it.next() :返回迭代器的下一个元素，并且更新迭代器的状态
it.hasNext():用于检测集合中是否还有元素
it.remove() :将迭代器返回的元素删除
ArrayList<String> sites = new ArrayList<String>();
// 获取迭代器
Iterator<String> it = sites.iterator();
while(it.hasNext()) {
Integer i = it.next();
if(i < 10) {
it.remove(); // 删除小于 10 的元素
}
}
Object类
Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法，Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。
Java 泛型
// 泛型方法 printArray
public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
printArray( intArray ); // 传递一个整型数组
printArray( doubleArray ); // 传递一个双精度型数组
printArray( charArray ); // 传递一个字符型数组
类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类
Java 序列化
Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
整个过程都是 Java 虚拟机（JVM）独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象。
类 ObjectInputStream 和 ObjectOutputStream 是高层次的数据流，它们包含反序列化和序列化对象的方法。
ObjectOutputStream 类包含很多写方法来写各种数据类型
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
